@myclub_se/data-access 1.1.0

package/esm2020/lib/services/activity.service.mjs

@@ -0,0 +1,178 @@
+import { Injectable } from '@angular/core';
+import { Role, } from '../models';
+import { tap } from 'rxjs/operators';
+import { of } from 'rxjs';
+import { activityFactory, activityInviteFactory, activityLocationFactory, activitySettingsFactory, activityTypeFactory, eventFactory, searchMemberFactory, } from './factories';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+const MEMBER_ACTIVITY_INVITE_PATH = ':memberId/activities/:activityInviteId/';
+const MEMBER_ACTIVITY_INVITES_PATH = ':memberId/activities/';
+const MEMBER_CALENDAR_PATH = ':memberId/activities/calendar/';
+const PUBLIC_ACTIVITY_INVITE_PATH = 'activities/:id/:token/';
+const TEAM_ACTIVITIES_PATH = ':teamId/activities/';
+const TEAM_ACTIVITY_INVITES_PATH = ':teamId/activities/:activityId/invites/';
+const TEAM_ACTIVITY_LOCATIONS_PATH = ':teamId/activities/locations/';
+const TEAM_ACTIVITY_NEW_PATH = ':teamId/activities/new/';
+const TEAM_ACTIVITY_PARTICIPANTS_PATH = ':teamId/activities/:activityId/participants/';
+const TEAM_ACTIVITY_PATH = ':teamId/activities/:id/';
+const TEAM_ACTIVITY_SETTINGS_PATH = ':teamId/activities/settings/';
+const TEAM_ACTIVITY_TYPES_PATH = ':teamId/activities/types/';
+const TEAM_CALENDAR_PATH = ':teamId/activities/calendar/';
+export class ActivityService {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    addTeamActivityInvites(teamId, activityId, memberIds) {
+        return this.apiService
+            .postResource(() => true, Role.TeamAdmin, TEAM_ACTIVITY_INVITES_PATH, {
+            teamId,
+            activityId
+        }, {
+            members: memberIds
+        });
+    }
+    createTeamActivity(teamId, data) {
+        return this.apiService
+            .postResource(activityFactory, Role.TeamAdmin, TEAM_ACTIVITIES_PATH, {
+            teamId
+        }, data);
+    }
+    deleteTeamActivity(teamId, id) {
+        return this.apiService
+            .deleteResource(Role.TeamAdmin, TEAM_ACTIVITY_PATH, {
+            teamId,
+            id
+        });
+    }
+    getMemberActivityInvite(memberId, activityInviteId) {
+        return this.apiService
+            .getResource(activityInviteFactory, Role.MemberAdmin, MEMBER_ACTIVITY_INVITE_PATH, {
+            memberId,
+            activityInviteId
+        });
+    }
+    getMemberActivityInvites(memberId) {
+        const params = { limit: 'null' };
+        return this.apiService
+            .getCollection(activityInviteFactory, Role.MemberAdmin, MEMBER_ACTIVITY_INVITES_PATH, { memberId }, {
+            params
+        });
+    }
+    getMemberCalendarEvents(memberId, startDate = null, endDate = null) {
+        const params = { limit: 'null' };
+        if (startDate) {
+            params['search_start_day'] = startDate;
+        }
+        if (endDate) {
+            params['search_end_day'] = endDate;
+        }
+        return this.apiService
+            .getCollection(eventFactory, Role.MemberAdmin, MEMBER_CALENDAR_PATH, { memberId }, {
+            params
+        });
+    }
+    getPublicActivityInvite(id, token) {
+        return this.apiService
+            .getResource(activityInviteFactory, Role.Public, PUBLIC_ACTIVITY_INVITE_PATH, {
+            id,
+            token
+        });
+    }
+    getTeamActivity(teamId, id) {
+        return this.apiService
+            .getResource(activityFactory, Role.TeamAdmin, TEAM_ACTIVITY_PATH, { teamId, id });
+    }
+    getTeamActivityLocations(teamId) {
+        if (this.activityLocationResponseDate && this.activityLocationResponseDate > this.subtractHours(new Date(), 1)) {
+            return of(this.activityLocationCollection);
+        }
+        return this.apiService
+            .getCollection(activityLocationFactory, Role.TeamAdmin, TEAM_ACTIVITY_LOCATIONS_PATH, { teamId }, { params: { limit: 'null' } }).pipe(tap((activityLocationCollection) => {
+            this.activityLocationResponseDate = new Date();
+            this.activityLocationCollection = activityLocationCollection;
+        }));
+    }
+    getTeamActivityNew(teamId) {
+        return this.apiService
+            .getResource(activityFactory, Role.TeamAdmin, TEAM_ACTIVITY_NEW_PATH, { teamId });
+    }
+    getTeamActivityParticipants(teamId, activityId) {
+        return this.apiService
+            .getCollection(searchMemberFactory, Role.TeamAdmin, TEAM_ACTIVITY_PARTICIPANTS_PATH, {
+            teamId,
+            activityId
+        }, { params: { limit: 'null' } });
+    }
+    getTeamActivitySettings(teamId) {
+        return this.apiService
+            .getResource(activitySettingsFactory, Role.TeamAdmin, TEAM_ACTIVITY_SETTINGS_PATH, {
+            teamId
+        });
+    }
+    getTeamActivityTypes(teamId) {
+        if (this.activityTypeResponseDate && this.activityTypeResponseDate > this.subtractHours(new Date(), 1)) {
+            return of(this.activityTypeCollection);
+        }
+        return this.apiService
+            .getCollection(activityTypeFactory, Role.TeamAdmin, TEAM_ACTIVITY_TYPES_PATH, { teamId }, { params: { limit: 'null' } }).pipe(tap((activityTypeCollection) => {
+            this.activityTypeResponseDate = new Date();
+            this.activityTypeCollection = activityTypeCollection;
+        }));
+    }
+    getTeamCalendarEvents(teamId, startDate = null, endDate = null) {
+        const params = { limit: 'null' };
+        if (startDate) {
+            params['search_start_day'] = startDate;
+        }
+        if (endDate) {
+            params['search_end_day'] = endDate;
+        }
+        return this.apiService
+            .getCollection(eventFactory, Role.TeamAdmin, TEAM_CALENDAR_PATH, { teamId }, {
+            params
+        });
+    }
+    updateMemberActivity(memberId, activityInviteId, activityInvite) {
+        return this.apiService
+            .updateResource(activityInviteFactory, Role.MemberAdmin, MEMBER_ACTIVITY_INVITE_PATH, {
+            memberId,
+            activityInviteId
+        }, activityInvite);
+    }
+    updatePublicActivityInvite(id, token, activityInvite) {
+        return this.apiService
+            .updateResource(activityInviteFactory, Role.Public, PUBLIC_ACTIVITY_INVITE_PATH, {
+            id,
+            token
+        }, activityInvite);
+    }
+    updateTeamActivity(teamId, activity) {
+        return this.apiService
+            .updateResource(activityFactory, Role.TeamAdmin, TEAM_ACTIVITY_PATH, {
+            teamId,
+            id: activity.id
+        }, activity);
+    }
+    updateTeamActivityParticipants(teamId, activityId, members) {
+        return this.apiService
+            .postResource(() => { }, Role.TeamAdmin, TEAM_ACTIVITY_PARTICIPANTS_PATH, {
+            teamId,
+            activityId
+        }, {
+            members
+        });
+    }
+    subtractHours(date, hours) {
+        date.setHours(date.getHours() - hours);
+        return date;
+    }
+}
+ActivityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ActivityService, deps: [{ token: i1.ApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ActivityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ActivityService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ActivityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"activity.service.js","sourceRoot":"","sources":["../../../../../projects/data-access/src/lib/services/activity.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { ApiService } from './api.service';\nimport { Activity, ActivityLocation, ActivityType, Collection, Role, } from '../models';\nimport { tap } from 'rxjs/operators';\nimport { of } from 'rxjs';\nimport {\n  activityFactory,\n  activityInviteFactory,\n  activityLocationFactory,\n  activitySettingsFactory,\n  activityTypeFactory,\n  eventFactory,\n  searchMemberFactory,\n} from './factories';\n\nconst MEMBER_ACTIVITY_INVITE_PATH = ':memberId/activities/:activityInviteId/';\nconst MEMBER_ACTIVITY_INVITES_PATH = ':memberId/activities/';\nconst MEMBER_CALENDAR_PATH = ':memberId/activities/calendar/';\nconst PUBLIC_ACTIVITY_INVITE_PATH = 'activities/:id/:token/';\nconst TEAM_ACTIVITIES_PATH = ':teamId/activities/';\nconst TEAM_ACTIVITY_INVITES_PATH = ':teamId/activities/:activityId/invites/';\nconst TEAM_ACTIVITY_LOCATIONS_PATH = ':teamId/activities/locations/';\nconst TEAM_ACTIVITY_NEW_PATH = ':teamId/activities/new/';\nconst TEAM_ACTIVITY_PARTICIPANTS_PATH = ':teamId/activities/:activityId/participants/';\nconst TEAM_ACTIVITY_PATH = ':teamId/activities/:id/';\nconst TEAM_ACTIVITY_SETTINGS_PATH = ':teamId/activities/settings/';\nconst TEAM_ACTIVITY_TYPES_PATH = ':teamId/activities/types/';\nconst TEAM_CALENDAR_PATH = ':teamId/activities/calendar/';\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ActivityService {\n  activityLocationCollection: Collection<ActivityLocation> | undefined;\n  activityTypeCollection: Collection<ActivityType> | undefined;\n\n  activityLocationResponseDate: Date | undefined;\n  activityTypeResponseDate: Date | undefined;\n\n  constructor(private apiService: ApiService) { }\n\n  addTeamActivityInvites(teamId: string, activityId: string, memberIds: Array<string>) {\n    return this.apiService\n      .postResource(\n        () => true,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_INVITES_PATH,\n        {\n          teamId,\n          activityId\n        },\n        {\n          members: memberIds\n        }\n      )\n  }\n\n  createTeamActivity(teamId: string, data: Activity) {\n    return this.apiService\n      .postResource(\n        activityFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITIES_PATH,\n        {\n          teamId\n        },\n        data\n      )\n  }\n\n  deleteTeamActivity(teamId: string, id: string) {\n    return this.apiService\n      .deleteResource(\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_PATH,\n        {\n          teamId,\n          id\n        }\n      );\n  }\n\n  getMemberActivityInvite(memberId: string, activityInviteId: string) {\n    return this.apiService\n      .getResource(\n        activityInviteFactory,\n        Role.MemberAdmin,\n        MEMBER_ACTIVITY_INVITE_PATH,\n        {\n          memberId,\n          activityInviteId\n        }\n      )\n  }\n\n  getMemberActivityInvites(memberId: string) {\n    const params: { [key: string]: string } = { limit: 'null'};\n\n    return this.apiService\n      .getCollection(\n        activityInviteFactory,\n        Role.MemberAdmin,\n        MEMBER_ACTIVITY_INVITES_PATH,\n        {memberId},\n        {\n          params\n        }\n      );\n  }\n\n  getMemberCalendarEvents(memberId: string, startDate: string | null = null, endDate: string | null = null) {\n    const params: { [key: string]: string } = { limit: 'null' };\n\n    if (startDate) {\n      params['search_start_day'] = startDate;\n    }\n\n    if (endDate) {\n      params['search_end_day'] = endDate;\n    }\n\n    return this.apiService\n      .getCollection(\n        eventFactory,\n        Role.MemberAdmin,\n        MEMBER_CALENDAR_PATH,\n        {memberId},\n        {\n          params\n        }\n      )\n  }\n\n  getPublicActivityInvite(id: string, token: string) {\n    return this.apiService\n      .getResource(\n        activityInviteFactory,\n        Role.Public,\n        PUBLIC_ACTIVITY_INVITE_PATH,\n        {\n          id,\n          token\n        }\n      );\n  }\n\n  getTeamActivity(teamId: string, id: string) {\n    return this.apiService\n      .getResource(\n        activityFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_PATH,\n        {teamId, id}\n      )\n  }\n\n  getTeamActivityLocations(teamId: string) {\n    if (this.activityLocationResponseDate && this.activityLocationResponseDate > this.subtractHours(new Date(), 1)) {\n      return of(this.activityLocationCollection);\n    }\n\n    return this.apiService\n      .getCollection(\n        activityLocationFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_LOCATIONS_PATH,\n        {teamId},\n        { params: { limit: 'null' } }\n      ).pipe(\n        tap((activityLocationCollection: Collection<ActivityLocation>) => {\n          this.activityLocationResponseDate = new Date();\n          this.activityLocationCollection = activityLocationCollection;\n        })\n      );\n  }\n\n  getTeamActivityNew(teamId: string) {\n    return this.apiService\n      .getResource(\n        activityFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_NEW_PATH,\n        {teamId}\n      );\n  }\n\n  getTeamActivityParticipants(teamId: string, activityId: string) {\n    return this.apiService\n      .getCollection(\n        searchMemberFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_PARTICIPANTS_PATH,\n        {\n          teamId,\n          activityId\n        },\n        { params: { limit: 'null' } }\n      );\n  }\n\n  getTeamActivitySettings(teamId: string) {\n    return this.apiService\n      .getResource(\n        activitySettingsFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_SETTINGS_PATH,\n        {\n          teamId\n        }\n      );\n  }\n\n  getTeamActivityTypes(teamId: string) {\n    if (this.activityTypeResponseDate && this.activityTypeResponseDate > this.subtractHours(new Date(), 1)) {\n      return of(this.activityTypeCollection);\n    }\n\n    return this.apiService\n      .getCollection(\n        activityTypeFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_TYPES_PATH,\n        {teamId},\n        { params: { limit: 'null' } }\n      ).pipe(\n        tap((activityTypeCollection: Collection<ActivityType>) => {\n          this.activityTypeResponseDate = new Date();\n          this.activityTypeCollection = activityTypeCollection;\n        })\n      )\n  }\n\n  getTeamCalendarEvents(teamId: string, startDate: string | null = null, endDate: string | null = null) {\n    const params: { [key: string]: string } = { limit: 'null' };\n\n    if (startDate) {\n      params['search_start_day'] = startDate;\n    }\n\n    if (endDate) {\n      params['search_end_day'] = endDate;\n    }\n\n    return this.apiService\n      .getCollection(\n        eventFactory,\n        Role.TeamAdmin,\n        TEAM_CALENDAR_PATH,\n        {teamId},\n        {\n          params\n        }\n      );\n  }\n\n  updateMemberActivity(memberId: string, activityInviteId: string, activityInvite: unknown) {\n    return this.apiService\n      .updateResource(\n        activityInviteFactory,\n        Role.MemberAdmin,\n        MEMBER_ACTIVITY_INVITE_PATH,\n        {\n          memberId,\n          activityInviteId\n        },\n        activityInvite\n      );\n  }\n\n  updatePublicActivityInvite(id: string, token: string, activityInvite: unknown) {\n    return this.apiService\n      .updateResource(\n        activityInviteFactory,\n        Role.Public,\n        PUBLIC_ACTIVITY_INVITE_PATH,\n        {\n          id,\n          token\n        },\n        activityInvite\n      )\n  }\n\n  updateTeamActivity(teamId: string, activity: Activity) {\n    return this.apiService\n      .updateResource(\n        activityFactory,\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_PATH,\n        {\n          teamId,\n          id: activity.id\n        },\n        activity\n      );\n  }\n\n  updateTeamActivityParticipants(teamId: string, activityId: string, members: Array<string>) {\n    return this.apiService\n      .postResource(\n        () => {},\n        Role.TeamAdmin,\n        TEAM_ACTIVITY_PARTICIPANTS_PATH,\n        {\n          teamId,\n          activityId\n        },\n        {\n          members\n        }\n      );\n  }\n\n  private subtractHours(date: Date, hours: number): Date {\n    date.setHours(date.getHours() - hours);\n\n    return date;\n  }\n}\n"]}

package/esm2020/lib/services/api.service.mjs

@@ -0,0 +1,85 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { map } from 'rxjs/operators';
+import { Collection, Role } from '../models';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export const DOMAIN = new InjectionToken('domain');
+const API_PATH = 'api/v3/';
+const ROLE_PATH = {
+    [Role.ClubAdmin]: 'club-admin/',
+    [Role.SectionAdmin]: 'section-admin/',
+    [Role.TeamAdmin]: 'team-admin/',
+    [Role.MemberAdmin]: 'member-admin/',
+    [Role.Public]: 'public/',
+    [Role.None]: ''
+};
+export class ApiService {
+    constructor(http, domain) {
+        this.http = http;
+        this.domain = domain;
+    }
+    deleteResource(role, path, pathParams = {}, options = {}) {
+        return this.delete(role, path, pathParams, options)
+            .pipe(map((response) => response.status === 204));
+    }
+    getCollection(factory, role, path, pathParams = {}, options = {}) {
+        return this.get(role, path, pathParams, options).pipe(map((apiCollection) => {
+            const resources = apiCollection.results.map((resource) => factory(resource));
+            return new Collection(apiCollection.count, apiCollection.next, apiCollection.previous, resources);
+        }));
+    }
+    getResource(factory, role, path, pathParams = {}, options = {}) {
+        return this.get(role, path, pathParams, options).pipe(map((apiResource) => factory(apiResource)));
+    }
+    postFormData(factory, role, path, pathParams = {}, data) {
+        const body = new FormData();
+        for (const [key, value] of Object.entries(data)) {
+            body.append(key, value);
+        }
+        return this.http.post(this.url(this.path(role, path, pathParams)), body)
+            .pipe(map((apiResource) => factory(apiResource)));
+    }
+    postResource(factory, role, path, pathParams = {}, data, options = {}) {
+        return this.post(role, path, pathParams, data, options).pipe(map((apiResource) => factory(apiResource)));
+    }
+    updateResource(responseFactory, role, path, pathParams = {}, data, options = {}) {
+        return this.patch(role, path, pathParams, data, options).pipe(map((apiResource) => responseFactory(apiResource)));
+    }
+    delete(role, path, pathParams, options) {
+        if (options.body) {
+            return this.http.request('delete', this.url(this.path(role, path, pathParams)), options);
+        }
+        return this.http.delete(this.url(this.path(role, path, pathParams)), { ...options, observe: 'response' });
+    }
+    get(role, path, pathParams, options) {
+        return this.http.get(this.url(this.path(role, path, pathParams)), options);
+    }
+    patch(role, path, pathParams, data, options) {
+        return this.http.patch(this.url(this.path(role, path, pathParams)), data, options);
+    }
+    path(role, path, params) {
+        for (const [key, value] of Object.entries(params)) {
+            const regexp = new RegExp(':' + key, 'g');
+            path = path.replace(regexp, value);
+        }
+        return ROLE_PATH[role] + path;
+    }
+    post(role, path, pathParams, data, options) {
+        return this.http.post(this.url(this.path(role, path, pathParams)), data, options);
+    }
+    url(path) {
+        return this.domain + API_PATH + path;
+    }
+}
+ApiService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ApiService, deps: [{ token: i1.HttpClient }, { token: DOMAIN }], target: i0.ɵɵFactoryTarget.Injectable });
+ApiService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ApiService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ApiService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DOMAIN]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"api.service.js","sourceRoot":"","sources":["../../../../../projects/data-access/src/lib/services/api.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpResponse } from '@angular/common/http';\nimport { Inject, Injectable, InjectionToken } from '@angular/core';\nimport { map } from 'rxjs/operators';\nimport { ApiCollection } from '../api-models';\nimport { Collection, Role } from '../models';\n\nexport const DOMAIN = new InjectionToken<string>('domain');\n\nconst API_PATH = 'api/v3/';\n\nconst ROLE_PATH = {\n  [Role.ClubAdmin]: 'club-admin/',\n  [Role.SectionAdmin]: 'section-admin/',\n  [Role.TeamAdmin]: 'team-admin/',\n  [Role.MemberAdmin]: 'member-admin/',\n  [Role.Public]: 'public/',\n  [Role.None]: ''\n};\n\ninterface Factory<A, T> {\n  (apiResource: A): T;\n}\n\ninterface PathParams {\n  [key: string]: string;\n}\n\ninterface Options {\n  params?: { [key: string]: string | Array<string>};\n  body?: any;\n}\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ApiService {\n  constructor(\n    private http: HttpClient,\n    @Inject(DOMAIN) private domain: string\n  ) {}\n\n  deleteResource(\n    role: Role,\n    path: string,\n    pathParams: PathParams = {},\n    options: Options = {}\n  ) {\n    return this.delete(role, path, pathParams, options)\n      .pipe(\n        map((response: HttpResponse<unknown>) => response.status === 204)\n      );\n  }\n\n  getCollection<A, T>(\n    factory: Factory<A, T>,\n    role: Role,\n    path: string,\n    pathParams: PathParams = {},\n    options: Options = { }\n  ) {\n    return this.get<ApiCollection<A>>(role, path, pathParams, options).pipe(\n      map((apiCollection) => {\n        const resources = apiCollection.results.map((resource) => factory(resource));\n        return new Collection<T>(apiCollection.count, apiCollection.next, apiCollection.previous, resources);\n      })\n    );\n  }\n\n  getResource<A, T>(\n    factory: Factory<A, T>,\n    role: Role,\n    path: string,\n    pathParams: PathParams = {},\n    options: Options = {}\n  ) {\n    return this.get<A>(role, path, pathParams, options).pipe(\n      map((apiResource) => factory(apiResource))\n    );\n  }\n\n  postFormData<A, T>(\n    factory: Factory<A, T>,\n    role: Role,\n    path: string,\n    pathParams: PathParams = {},\n    data: { [key: string]: string }) {\n    const body = new FormData();\n\n    for (const [key, value] of Object.entries(data)) {\n      body.append(key, value);\n    }\n\n    return this.http.post<A>(this.url(this.path(role, path, pathParams)), body)\n      .pipe(map((apiResource) => factory(apiResource)));\n  }\n\n  postResource<A, T>(\n    factory: Factory<A, T>,\n    role: Role,\n    path: string,\n    pathParams: PathParams = {},\n    data: unknown,\n    options: Options = {}) {\n    return this.post<A>(role, path, pathParams, data, options).pipe(\n      map((apiResource) => factory(apiResource))\n    );\n  }\n\n  updateResource<A, T>(\n    responseFactory: Factory<A, T>,\n    role: Role,\n    path: string,\n    pathParams: PathParams = {},\n    data: unknown,\n    options: Options = {}) {\n    return this.patch<A>(role, path, pathParams, data, options).pipe(\n      map((apiResource) => responseFactory(apiResource))\n    );\n  }\n\n  private delete(role: Role, path: string, pathParams: PathParams, options: Options) {\n    if (options.body) {\n      return this.http.request<any>('delete', this.url(this.path(role, path, pathParams)), options);\n    }\n\n    return this.http.delete(this.url(this.path(role, path, pathParams)), {...options, observe: 'response'});\n  }\n\n  private get<T>(role: Role, path: string, pathParams: PathParams, options: Options) {\n    return this.http.get<T>(this.url(this.path(role, path, pathParams)), options);\n  }\n\n  private patch<T>(role: Role, path: string, pathParams: PathParams, data: unknown, options: Options) {\n      return this.http.patch<T>(this.url(this.path(role, path, pathParams)), data, options);\n  }\n\n  private path(role: Role, path: string, params: PathParams) {\n    for (const [key, value] of Object.entries(params)) {\n      const regexp = new RegExp(':' + key, 'g');\n      path = path.replace(regexp, value);\n    }\n\n    return ROLE_PATH[role] + path;\n  }\n\n  private post<T>(role: Role, path: string, pathParams: PathParams, data: unknown, options: Options) {\n    return this.http.post<T>(this.url(this.path(role, path, pathParams)), data, options);\n  }\n\n  private url(path: string) {\n    return this.domain + API_PATH + path;\n  }\n}\n"]}

package/esm2020/lib/services/auth.service.mjs

@@ -0,0 +1,56 @@
+import { Injectable } from '@angular/core';
+import { catchError, map } from 'rxjs/operators';
+import { Role } from '../models';
+import { of } from 'rxjs';
+import { authFactory } from './factories';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+const AUTHS_PATH = 'every-admin/auths/';
+const REMOVE_AUTH_PATH = 'accounts/remove-auth/:authId/:authType/:id/';
+export class AuthService {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    getAuth(id) {
+        return this.apiService
+            .getCollection(authFactory, Role.None, AUTHS_PATH, {}, { params: { club_id: id } })
+            .pipe(map((collection) => {
+            if (collection.count === 0) {
+                return null;
+            }
+            return collection.toArray()[0];
+        }));
+    }
+    getAuths(role = null) {
+        return this.apiService.getCollection(authFactory, Role.None, AUTHS_PATH, {}, role ? { params: { role } } : {});
+    }
+    removeClubAuth(authId, clubId) {
+        return this.removeAuth(authId, clubId, 'club');
+    }
+    removeMemberAuth(authId, memberId) {
+        return this.removeAuth(authId, memberId, 'member');
+    }
+    removeSectionAuth(authId, sectionId) {
+        return this.removeAuth(authId, sectionId, 'section');
+    }
+    removeTeamAuth(authId, teamId) {
+        return this.removeAuth(authId, teamId, 'team');
+    }
+    removeAuth(authId, authTypeId, authType) {
+        return this.apiService.postResource(() => { }, Role.None, REMOVE_AUTH_PATH, {
+            authId,
+            authType,
+            id: authTypeId
+        }, {})
+            .pipe(map(() => true), catchError(() => of(false)));
+    }
+}
+AuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: AuthService, deps: [{ token: i1.ApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+AuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: AuthService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: AuthService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/club.service.mjs

@@ -0,0 +1,29 @@
+import { Injectable } from '@angular/core';
+import { Role } from '../models';
+import { searchClubFactory } from './factories';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+const MEMBER_CLUB_INFO = ':memberId/club-info/';
+const TEAM_CLUB_INFO = ':teamId/club-info/';
+export class ClubService {
+    constructor(apiService) {
+        this.apiService = apiService;
+    }
+    getMemberClubInfo(memberId) {
+        return this.apiService
+            .getResource(searchClubFactory, Role.MemberAdmin, MEMBER_CLUB_INFO, { memberId });
+    }
+    getTeamClubInfo(teamId) {
+        return this.apiService
+            .getResource(searchClubFactory, Role.TeamAdmin, TEAM_CLUB_INFO, { teamId });
+    }
+}
+ClubService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ClubService, deps: [{ token: i1.ApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ClubService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ClubService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ClubService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/services/constant.service.mjs

@@ -0,0 +1,131 @@
+import { Injectable } from '@angular/core';
+import { map, tap } from 'rxjs/operators';
+import { of } from 'rxjs';
+import { Role } from '../models';
+import * as i0 from "@angular/core";
+import * as i1 from "./api.service";
+const ACTIVITY_INVITE_SETTINGS_PATH = 'every-admin/constants/activity-invite-settings/';
+const ACTIVITY_MAX_ATTENDANT_TYPES_PATH = 'every-admin/constants/activity-max-attendant-types/';
+const ACTIVITY_MEET_UP_TIMES_PATH = 'every-admin/constants/activity-meet-up-times/';
+const ACTIVITY_REMINDER_DAYS_PATH = 'every-admin/constants/activity-invite-days/';
+const ACTIVITY_REMINDER_RECEIVERS_PATH = 'every-admin/constants/activity-remind-receivers/';
+const ACTIVITY_REMINDER_TIMES_PATH = 'every-admin/constants/activity-remind-hours/';
+const ACTIVITY_REPEAT_OPTIONS_PATH = 'every-admin/constants/activity-repeat-options/';
+const ACTIVITY_REPEAT_TYPE_OPTIONS_PATH = 'every-admin/constants/activity-repeat-type-options/';
+const COUNTRIES_PATH = 'every-admin/constants/countries/';
+const LANGUAGES_PATH = 'every-admin/constants/languages/';
+const MEMBER_CONTACT_TYPES_PATH = 'every-admin/constants/member-contact-types/';
+export class ConstantService {
+    constructor(apiService) {
+        this.apiService = apiService;
+        this.activityInviteSettings = [];
+        this.activityMaxAttendantTypes = [];
+        this.activityMeetUpTimes = [];
+        this.activityReminderDays = [];
+        this.activityReminderReceivers = [];
+        this.activityReminderTimes = [];
+        this.activityRepeatOptions = [];
+        this.activityRepeatTypeOptions = [];
+        this.countries = [];
+        this.languages = [];
+        this.memberContactTypes = [];
+    }
+    getActivityInviteSettings() {
+        if (this.activityInviteSettings.length) {
+            return of(this.activityInviteSettings);
+        }
+        return this.getConstants(ACTIVITY_INVITE_SETTINGS_PATH)
+            .pipe(tap((activityInviteSettings) => this.activityInviteSettings = activityInviteSettings));
+    }
+    getActivityMaxAttendantsTypes() {
+        if (this.activityMaxAttendantTypes.length) {
+            return of(this.activityMaxAttendantTypes);
+        }
+        return this.getConstants(ACTIVITY_MAX_ATTENDANT_TYPES_PATH)
+            .pipe(tap((activityMaxAttendantTypes) => this.activityMaxAttendantTypes = activityMaxAttendantTypes));
+    }
+    getActivityMeetUpTimes() {
+        if (this.activityMeetUpTimes.length) {
+            return of(this.activityMeetUpTimes);
+        }
+        return this.getConstants(ACTIVITY_MEET_UP_TIMES_PATH)
+            .pipe(tap((activityMeetUpTimes) => this.activityMeetUpTimes = activityMeetUpTimes));
+    }
+    getActivityReminderDays() {
+        if (this.activityReminderDays.length) {
+            return of(this.activityReminderDays);
+        }
+        return this.getConstants(ACTIVITY_REMINDER_DAYS_PATH)
+            .pipe(tap((activityReminderDays) => this.activityReminderDays = activityReminderDays));
+    }
+    getActivityReminderReceivers() {
+        if (this.activityReminderReceivers.length) {
+            return of(this.activityReminderReceivers);
+        }
+        return this.getConstants(ACTIVITY_REMINDER_RECEIVERS_PATH)
+            .pipe(tap((activityReminderReceivers) => this.activityReminderReceivers = activityReminderReceivers));
+    }
+    getActivityReminderTimes() {
+        if (this.activityReminderTimes.length) {
+            return of(this.activityReminderTimes);
+        }
+        return this.getConstants(ACTIVITY_REMINDER_TIMES_PATH)
+            .pipe(tap((activityReminderTimes) => this.activityReminderTimes = activityReminderTimes));
+    }
+    getActivityRepeatOptions() {
+        if (this.activityRepeatOptions.length) {
+            return of(this.activityRepeatOptions);
+        }
+        return this.getConstants(ACTIVITY_REPEAT_OPTIONS_PATH)
+            .pipe(tap((activityRepeatOptions) => this.activityRepeatOptions = activityRepeatOptions));
+    }
+    getActivityRepeatTypeOptions() {
+        if (this.activityRepeatTypeOptions.length) {
+            return of(this.activityRepeatTypeOptions);
+        }
+        return this.getConstants(ACTIVITY_REPEAT_TYPE_OPTIONS_PATH)
+            .pipe(tap((activityRepeatTypeOptions) => this.activityRepeatTypeOptions = activityRepeatTypeOptions));
+    }
+    getCountries() {
+        if (this.countries.length) {
+            return of(this.countries);
+        }
+        return this.getConstants(COUNTRIES_PATH)
+            .pipe(tap((countries) => this.countries = countries));
+    }
+    getLanguages() {
+        if (this.languages.length) {
+            return of(this.languages);
+        }
+        return this.getConstants(LANGUAGES_PATH)
+            .pipe(map((languages) => {
+            // FIXME: For now - remove the french language.
+            const index = languages.findIndex((language) => language.value === 'fr');
+            if (index !== -1) {
+                languages.splice(index, 1);
+            }
+            return languages;
+        }), tap((languages) => this.languages = languages));
+    }
+    getMemberContactTypes() {
+        if (this.memberContactTypes.length) {
+            return of(this.memberContactTypes);
+        }
+        return this.getConstants(MEMBER_CONTACT_TYPES_PATH)
+            .pipe(tap((memberContactTypes) => this.memberContactTypes = memberContactTypes));
+    }
+    getConstants(path) {
+        return this.apiService
+            .getCollection((option) => option, Role.None, path)
+            .pipe(map((response) => response.toArray()));
+    }
+}
+ConstantService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ConstantService, deps: [{ token: i1.ApiService }], target: i0.ɵɵFactoryTarget.Injectable });
+ConstantService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ConstantService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.11", ngImport: i0, type: ConstantService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.ApiService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"constant.service.js","sourceRoot":"","sources":["../../../../../projects/data-access/src/lib/services/constant.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { map, tap } from 'rxjs/operators';\nimport { Observable, of } from 'rxjs';\n\nimport { ApiService } from './api.service';\nimport { Collection, Role } from '../models';\nimport { OptionInterface } from '../interfaces';\n\nconst ACTIVITY_INVITE_SETTINGS_PATH = 'every-admin/constants/activity-invite-settings/';\nconst ACTIVITY_MAX_ATTENDANT_TYPES_PATH = 'every-admin/constants/activity-max-attendant-types/';\nconst ACTIVITY_MEET_UP_TIMES_PATH = 'every-admin/constants/activity-meet-up-times/';\nconst ACTIVITY_REMINDER_DAYS_PATH = 'every-admin/constants/activity-invite-days/';\nconst ACTIVITY_REMINDER_RECEIVERS_PATH = 'every-admin/constants/activity-remind-receivers/';\nconst ACTIVITY_REMINDER_TIMES_PATH = 'every-admin/constants/activity-remind-hours/';\nconst ACTIVITY_REPEAT_OPTIONS_PATH = 'every-admin/constants/activity-repeat-options/';\nconst ACTIVITY_REPEAT_TYPE_OPTIONS_PATH = 'every-admin/constants/activity-repeat-type-options/';\nconst COUNTRIES_PATH = 'every-admin/constants/countries/';\nconst LANGUAGES_PATH = 'every-admin/constants/languages/';\nconst MEMBER_CONTACT_TYPES_PATH = 'every-admin/constants/member-contact-types/';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class ConstantService {\n  private activityInviteSettings: Array<OptionInterface> = [];\n  private activityMaxAttendantTypes: Array<OptionInterface> = [];\n  private activityMeetUpTimes: Array<OptionInterface> = [];\n  private activityReminderDays: Array<OptionInterface> = [];\n  private activityReminderReceivers: Array<OptionInterface> = [];\n  private activityReminderTimes: Array<OptionInterface> = [];\n  private activityRepeatOptions: Array<OptionInterface> = [];\n  private activityRepeatTypeOptions: Array<OptionInterface> = [];\n  private countries: Array<OptionInterface> = [];\n  private languages: Array<OptionInterface> = [];\n  private memberContactTypes: Array<OptionInterface> = [];\n\n  constructor(private apiService: ApiService) {}\n\n  getActivityInviteSettings(): Observable<Array<OptionInterface>> {\n    if (this.activityInviteSettings.length) {\n      return of(this.activityInviteSettings);\n    }\n\n    return this.getConstants(ACTIVITY_INVITE_SETTINGS_PATH)\n      .pipe(tap((activityInviteSettings: Array<OptionInterface>) => this.activityInviteSettings = activityInviteSettings));\n  }\n\n  getActivityMaxAttendantsTypes(): Observable<Array<OptionInterface>> {\n    if (this.activityMaxAttendantTypes.length) {\n      return of(this.activityMaxAttendantTypes);\n    }\n\n    return this.getConstants(ACTIVITY_MAX_ATTENDANT_TYPES_PATH)\n      .pipe(tap((activityMaxAttendantTypes: Array<OptionInterface>) => this.activityMaxAttendantTypes = activityMaxAttendantTypes));\n  }\n\n  getActivityMeetUpTimes(): Observable<Array<OptionInterface>> {\n    if (this.activityMeetUpTimes.length) {\n      return of(this.activityMeetUpTimes);\n    }\n\n    return this.getConstants(ACTIVITY_MEET_UP_TIMES_PATH)\n      .pipe(tap((activityMeetUpTimes: Array<OptionInterface>) => this.activityMeetUpTimes = activityMeetUpTimes));\n  }\n\n  getActivityReminderDays(): Observable<Array<OptionInterface>> {\n    if (this.activityReminderDays.length) {\n      return of(this.activityReminderDays);\n    }\n\n    return this.getConstants(ACTIVITY_REMINDER_DAYS_PATH)\n      .pipe(tap((activityReminderDays: Array<OptionInterface>) => this.activityReminderDays = activityReminderDays));\n  }\n\n  getActivityReminderReceivers(): Observable<Array<OptionInterface>> {\n    if (this.activityReminderReceivers.length) {\n      return of(this.activityReminderReceivers);\n    }\n\n    return this.getConstants(ACTIVITY_REMINDER_RECEIVERS_PATH)\n      .pipe(tap((activityReminderReceivers: Array<OptionInterface>) => this.activityReminderReceivers = activityReminderReceivers));\n  }\n\n  getActivityReminderTimes(): Observable<Array<OptionInterface>> {\n    if (this.activityReminderTimes.length) {\n      return of(this.activityReminderTimes);\n    }\n\n    return this.getConstants(ACTIVITY_REMINDER_TIMES_PATH)\n      .pipe(tap((activityReminderTimes: Array<OptionInterface>) => this.activityReminderTimes = activityReminderTimes));\n  }\n\n  getActivityRepeatOptions(): Observable<Array<OptionInterface>> {\n    if (this.activityRepeatOptions.length) {\n      return of(this.activityRepeatOptions);\n    }\n\n    return this.getConstants(ACTIVITY_REPEAT_OPTIONS_PATH)\n      .pipe(tap((activityRepeatOptions: Array<OptionInterface>) => this.activityRepeatOptions = activityRepeatOptions));\n  }\n\n  getActivityRepeatTypeOptions(): Observable<Array<OptionInterface>> {\n    if (this.activityRepeatTypeOptions.length) {\n      return of(this.activityRepeatTypeOptions);\n    }\n\n    return this.getConstants(ACTIVITY_REPEAT_TYPE_OPTIONS_PATH)\n      .pipe(tap((activityRepeatTypeOptions: Array<OptionInterface>) => this.activityRepeatTypeOptions = activityRepeatTypeOptions));\n  }\n\n  getCountries(): Observable<Array<OptionInterface>> {\n    if (this.countries.length) {\n      return of(this.countries);\n    }\n\n    return this.getConstants(COUNTRIES_PATH)\n      .pipe(tap((countries: Array<OptionInterface>) => this.countries = countries));\n  }\n\n  getLanguages(): Observable<Array<OptionInterface>> {\n    if (this.languages.length) {\n      return of(this.languages);\n    }\n\n    return this.getConstants(LANGUAGES_PATH)\n      .pipe(\n        map((languages: Array<OptionInterface>) => {\n          // FIXME: For now - remove the french language.\n          const index = languages.findIndex((language: OptionInterface) => language.value === 'fr');\n          if (index !== -1) {\n            languages.splice(index, 1);\n          }\n\n          return languages;\n        }),\n        tap((languages: Array<OptionInterface>) => this.languages = languages)\n      );\n  }\n\n  getMemberContactTypes(): Observable<Array<OptionInterface>> {\n    if (this.memberContactTypes.length) {\n      return of(this.memberContactTypes);\n    }\n\n    return this.getConstants(MEMBER_CONTACT_TYPES_PATH)\n      .pipe(tap((memberContactTypes: Array<OptionInterface>) => this.memberContactTypes = memberContactTypes));\n  }\n\n  private getConstants(path: string): Observable<Array<OptionInterface>> {\n    return this.apiService\n      .getCollection<OptionInterface, OptionInterface>(\n        (option: OptionInterface) => option,\n        Role.None,\n        path\n      )\n      .pipe(\n        map((response: Collection<OptionInterface>) => response.toArray())\n      );\n  }\n}\n"]}