@passly-nl/data 0.1.0

package/src/service/MerchantService.ts

@@ -0,0 +1,117 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { AuthAdapter, CommonAdapter, MerchantAdapter, PaymentAdapter } from '#data/adapter';
+import type { ContractDto, MerchantDto, PaymentProviderDto, StatusResponseDto, UserDto, VatNumberDto } from '#data/dto';
+import type { Claim } from '#data/types';
+import { emptyNull } from '#data/util';
+
+export class MerchantService extends BaseService {
+    async get(merchantId: string): Promise<BaseResponse<MerchantDto>> {
+        return await this
+            .request(`/merchants/${merchantId}`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(MerchantAdapter.parseMerchantFromObject);
+    }
+
+    async getAccountManager(merchantId: string): Promise<BaseResponse<UserDto | null>> {
+        return await this
+            .request(`/merchants/${merchantId}/account-manager`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(AuthAdapter.parseUserFromObject);
+    }
+
+    async getClaims(merchantId: string): Promise<BaseResponse<Claim[]>> {
+        return await this
+            .request(`/merchants/${merchantId}/claims`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(r => Object.values(r) as Claim[]);
+    }
+
+    async getContract(merchantId: string): Promise<BaseResponse<ContractDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/contract`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(MerchantAdapter.parseContractFromObject);
+    }
+
+    async getPaymentProviders(merchantId: string): Promise<BaseResponse<PaymentProviderDto[]>> {
+        return await this
+            .request(`/merchants/${merchantId}/payment-providers`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runArrayAdapter(PaymentAdapter.parsePaymentProviderFromObject);
+    }
+
+    async getVatNumber(merchantId: string): Promise<BaseResponse<VatNumberDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/vat-number`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(MerchantAdapter.parseVatNumberFromObject);
+    }
+
+    async put(merchantId: string, merchant: MerchantDto): Promise<BaseResponse<MerchantDto>> {
+        return await this
+            .request(`/merchants/${merchantId}`)
+            .method('put')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .body({
+                name: merchant.name,
+                email: merchant.email,
+                phone_number: merchant.phoneNumber,
+                url: merchant.url,
+                chamber_of_commerce_number: merchant.chamberOfCommerceNumber,
+                vat_number: merchant.vatNumber,
+                address: {
+                    label: emptyNull(merchant.address.label),
+                    street: merchant.address.street,
+                    number: merchant.address.number,
+                    postal_code: merchant.address.postalCode,
+                    city: merchant.address.city,
+                    country_code: merchant.address.country
+                }
+            })
+            .runAdapter(MerchantAdapter.parseMerchantFromObject);
+    }
+
+    async postLogo(merchantId: string, picture: File): Promise<BaseResponse<StatusResponseDto>> {
+        const data = new FormData();
+        data.append('file', picture);
+
+        return await this
+            .request(`/merchants/${merchantId}/logo`)
+            .method('post')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body(data)
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+
+    async deleteLogo(merchantId: string): Promise<BaseResponse<StatusResponseDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/logo`)
+            .method('delete')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(CommonAdapter.parseStatusResponseFromObject);
+    }
+}

package/src/service/MerchantStatisticsService.ts

@@ -0,0 +1,14 @@
+import { type BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import type { ApexOptions } from 'apexcharts';
+
+export class MerchantStatisticsService extends BaseService {
+    async getRevenueTrend(merchantId: string): Promise<BaseResponse<ApexOptions>> {
+        return this
+            .request(`/merchants/${merchantId}/statistics/revenue-trend`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .runAdapter(r => r);
+    }
+}

package/src/service/MerchantTicketService.ts

@@ -0,0 +1,35 @@
+import { BaseResponse, BaseService, BlobResponse, QueryString } from '@basmilius/http-client';
+import { TicketAdapter } from '#data/adapter';
+import type { TicketDto } from '#data/dto';
+
+export class MerchantTicketService extends BaseService {
+    async get(merchantId: string, ticketId: string): Promise<BaseResponse<TicketDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/tickets/${ticketId}`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(TicketAdapter.parseTicketFromObject);
+    }
+
+    async getPass(merchantId: string, ticketId: string): Promise<BlobResponse> {
+        return await this
+            .request(`/merchants/${merchantId}/tickets/${ticketId}/pass`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .fetchBlob();
+    }
+
+    async getPDF(merchantId: string, ticketId: string): Promise<BlobResponse> {
+        return await this
+            .request(`/merchants/${merchantId}/tickets/${ticketId}/pdf`)
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .fetchBlob();
+    }
+}

package/src/service/MerchantTicketsService.ts

@@ -0,0 +1,26 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { TicketAdapter } from '#data/adapter';
+import type { TicketDto } from '#data/dto';
+
+export class MerchantTicketsService extends BaseService {
+    async get(merchantId: string, offset: number, limit: number, filter?: Record<string, string | number | boolean>): Promise<BaseResponse<Paginated<TicketDto>>> {
+        const query = QueryString
+            .builder()
+            .append('language', 'nl')
+            .append('offset', offset)
+            .append('limit', limit);
+
+        if (filter) {
+            Object
+                .entries(filter)
+                .forEach(([key, value]) => query.append(key, value));
+        }
+
+        return await this
+            .request(`/merchants/${merchantId}/tickets`)
+            .method('get')
+            .queryString(query)
+            .bearerToken()
+            .runPaginatedAdapter(TicketAdapter.parseTicketFromObject);
+    }
+}

package/src/service/MerchantUsersService.ts

@@ -0,0 +1,34 @@
+import { BaseResponse, BaseService, Paginated, QueryString } from '@basmilius/http-client';
+import { MerchantAdapter } from '#data/adapter';
+import type { InvitationDto, MerchantUserDto } from '#data/dto';
+import type { Claim } from '#data/types';
+
+export class MerchantUsersService extends BaseService {
+    async get(merchantId: string, offset: number, limit: number): Promise<BaseResponse<Paginated<MerchantUserDto>>> {
+        return await this
+            .request(`/merchants/${merchantId}/users`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl')
+                .append('offset', offset)
+                .append('limit', limit))
+            .bearerToken()
+            .runPaginatedAdapter(MerchantAdapter.parseMerchantUserFromObject);
+    }
+
+    async postInvite(merchantId: string, firstName: string, lastName: string, email: string, claims: Claim[]): Promise<BaseResponse<InvitationDto>> {
+        return await this
+            .request(`/merchants/${merchantId}/users/invite`)
+            .method('post')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .bearerToken()
+            .body({
+                first_name: firstName,
+                last_name: lastName,
+                email,
+                claims
+            })
+            .runAdapter(MerchantAdapter.parseInvitationFromObject);
+    }
+}

package/src/service/MerchantsService.ts

@@ -0,0 +1,15 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { MerchantAdapter } from '#data/adapter';
+import type { MerchantDto } from '#data/dto';
+
+export class MerchantsService extends BaseService {
+    async get(): Promise<BaseResponse<MerchantDto[]>> {
+        return await this
+            .request('/merchants')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runArrayAdapter(MerchantAdapter.parseMerchantFromObject);
+    }
+}

package/src/service/PublicOrderService.ts

@@ -0,0 +1,35 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { OrderAdapter, PaymentAdapter, PublicPayAdapter } from '#data/adapter';
+import type { OrderDto, PublicPaymentMethodDto, TransactionDto } from '#data/dto';
+
+export class PublicOrderService extends BaseService {
+    async get(orderId: string): Promise<BaseResponse<OrderDto>> {
+        return await this
+            .request(`/orders/${orderId}`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(OrderAdapter.parseOrderFromObject);
+    }
+
+    async getPaymentMethods(orderId: string): Promise<BaseResponse<PublicPaymentMethodDto[]>> {
+        return await this
+            .request(`/orders/${orderId}/payment-methods`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runArrayAdapter(PublicPayAdapter.parsePublicPaymentMethodFromObject);
+    }
+
+    async postPay(orderId: string, paymentMethodId: string): Promise<BaseResponse<TransactionDto>> {
+        return await this
+            .request(`/orders/${orderId}/pay`)
+            .method('post')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                payment_method_id: paymentMethodId
+            })
+            .runAdapter(PaymentAdapter.parseTransactionFromObject);
+    }
+}

package/src/service/PublicShopService.ts

@@ -0,0 +1,49 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import type { DateTime } from 'luxon';
+import { OrderAdapter, PublicShopAdapter } from '#data/adapter';
+import type { OrderDto, PublicShopCartProductDto, PublicShopDto, PublicShopReservationDto } from '#data/dto';
+import type { Gender } from '#data/types';
+
+export class PublicShopService extends BaseService {
+    async get(shopId: string): Promise<BaseResponse<PublicShopDto>> {
+        return await this
+            .request(`/shops/${shopId}`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(PublicShopAdapter.parsePublicShopFromObject);
+    }
+
+    async buy(shopId: string, reservationId: string, firstName: string, lastName: string, email: string, phoneNumber: string, dateOfBirth: DateTime | null, gender: Gender | null): Promise<BaseResponse<OrderDto>> {
+        return await this
+            .request(`/shops/${shopId}/buy/${reservationId}`)
+            .method('post')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                first_name: firstName,
+                last_name: lastName,
+                email: email,
+                phone_number: phoneNumber.trim() === '' ? null : phoneNumber.trim(),
+                date_of_birth: dateOfBirth?.toISODate(),
+                gender: gender
+            })
+            .runAdapter(OrderAdapter.parseOrderFromObject);
+    }
+
+    async reserve(shopId: string, products: PublicShopCartProductDto[]): Promise<BaseResponse<PublicShopReservationDto>> {
+        return await this
+            .request(`/shops/${shopId}/reserve`)
+            .method('post')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .body({
+                products: products.map(p => [
+                    p.productId,
+                    p.quantity,
+                    p.timeSlotId
+                ])
+            })
+            .runAdapter(PublicShopAdapter.parsePublicShopReservationFromObject);
+    }
+}

package/src/service/ReservationService.ts

@@ -0,0 +1,23 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import { ReservationAdapter } from '#data/adapter';
+import type { ReservationDto } from '#data/dto';
+
+export class ReservationService extends BaseService {
+    async get(id: string): Promise<BaseResponse<ReservationDto>> {
+        return await this
+            .request(`/reservations/${id}`)
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter(ReservationAdapter.parseReservationFromObject);
+    }
+
+    async remove(id: string): Promise<BaseResponse<never>> {
+        return await this
+            .request(`/reservations/${id}`)
+            .method('delete')
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .run();
+    }
+}

package/src/service/ServicesService.ts

@@ -0,0 +1,18 @@
+import { type BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+
+export class ServicesService extends BaseService {
+    async checkEmail(email: string): Promise<BaseResponse<CheckEmailResponse>> {
+        return await this
+            .request('/service/check-email')
+            .method('get')
+            .queryString(QueryString.builder()
+                .append('email', email)
+                .append('language', 'nl'))
+            .runAdapter(r => r as CheckEmailResponse);
+    }
+}
+
+type CheckEmailResponse = {
+    readonly email: string;
+    readonly suggestions?: string[];
+};

package/src/service/UiSelectOptionsService.ts

@@ -0,0 +1,33 @@
+import { BaseResponse, BaseService, QueryString } from '@basmilius/http-client';
+import type { FluxFormSelectEntry, FluxFormSelectOption } from '@flux-ui/types';
+
+export class UiSelectOptionsService extends BaseService {
+    async getClaims(): Promise<BaseResponse<FluxFormSelectEntry[]>> {
+        return await this
+            .request('/ui/select-options/claims')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runAdapter((grouped: any) => {
+                const result: FluxFormSelectEntry[] = [];
+
+                grouped.forEach(group => {
+                    result.push({icon: group.icon, label: group.label});
+                    group.claims.forEach(claim => result.push({label: claim.label, value: claim.value}));
+                });
+
+                return result;
+            });
+    }
+
+    async getCountries(): Promise<BaseResponse<FluxFormSelectOption[]>> {
+        return await this
+            .request('/ui/select-options/countries')
+            .method('get')
+            .bearerToken()
+            .queryString(QueryString.builder()
+                .append('language', 'nl'))
+            .runArrayAdapter<FluxFormSelectOption>(e => e as FluxFormSelectOption);
+    }
+}

package/src/service/index.ts

@@ -0,0 +1,32 @@
+export * from './AuthService';
+export * from './InvitationService';
+export * from './MerchantService';
+export * from './MerchantsService';
+export * from './MerchantBuyerService';
+export * from './MerchantBuyersService';
+export * from './MerchantDashboardService';
+export * from './MerchantEventProductService';
+export * from './MerchantEventProductsService';
+export * from './MerchantEventService';
+export * from './MerchantEventStatisticsService';
+export * from './MerchantEventShopService';
+export * from './MerchantEventShopsService';
+export * from './MerchantEventStockPoolsService';
+export * from './MerchantEventTicketTemplateService';
+export * from './MerchantEventTicketTemplatesService';
+export * from './MerchantEventsService';
+export * from './MerchantFinanceInvoiceService';
+export * from './MerchantFinanceInvoicesService';
+export * from './MerchantFinanceService';
+export * from './MerchantOrderService';
+export * from './MerchantOrdersService';
+export * from './MerchantStatisticsService';
+export * from './MerchantTicketService';
+export * from './MerchantTicketsService';
+export * from './MerchantUsersService';
+export * from './MeService';
+export * from './PublicOrderService';
+export * from './PublicShopService';
+export * from './ReservationService';
+export * from './ServicesService';
+export * from './UiSelectOptionsService';

package/src/types/auth.ts

@@ -0,0 +1,47 @@
+export type Claim =
+    | 'admin:view'
+    | 'auth:login'
+    | 'buyers:view'
+    | 'events:create'
+    | 'events:manage'
+    | 'events:publish'
+    | 'events:statistics'
+    | 'events:unpublish'
+    | 'events:view'
+    | 'events:tickets:export'
+    | 'events:tickets:scan'
+    | 'events:tickets:view'
+    | 'finance:export'
+    | 'finance:view'
+    | 'finance:invoices:view'
+    | 'merchant:admin'
+    | 'merchant:users'
+    | 'orders:export'
+    | 'orders:view'
+    | 'statistics:view'
+    | 'tasks:view';
+
+export type UserTokenType =
+    | 'access_token'
+    | 'authorization_code'
+    | 'refresh_token'
+    | 'session';
+
+export type BrowserType =
+    | 'brave'
+    | 'chrome'
+    | 'edge'
+    | 'firefox'
+    | 'opera'
+    | 'safari'
+    | 'samsunginternet'
+    | 'vivaldi';
+
+export type OperatingSystemType =
+    | 'ios'
+    | 'ipados'
+    | 'macos'
+    | 'windows'
+    | 'linux'
+    | 'android'
+    | 'chromeos';

package/src/types/event.ts

@@ -0,0 +1,28 @@
+export type EventStatus =
+    | 'active'
+    | 'concluded'
+    | 'happening'
+    | 'in_sale'
+    | 'pending';
+
+export type ShopElementType =
+    | 'button'
+    | 'divider'
+    | 'heading'
+    | 'notice'
+    | 'product'
+    | 'text';
+
+export type ShopFieldRequirement =
+    | 'disabled'
+    | 'enabled'
+    | 'required';
+
+export type ShopStatus =
+    | 'closed'
+    | 'concluded'
+    | 'in_sale'
+    | 'pending';
+
+export type TicketTemplateType =
+    | 'default';

package/src/types/finance.ts

@@ -0,0 +1,14 @@
+export type DailyRevenueChart = {
+    current: DailyRevenueChartEntry[];
+    previous: DailyRevenueChartEntry[];
+};
+
+export type DailyRevenueChartEntry = {
+    readonly date: string;
+    readonly label: string;
+    readonly value: number;
+};
+
+export type InvoiceLineType =
+    | 'fee'
+    | 'manual';

package/src/types/general.ts

@@ -0,0 +1,19 @@
+export type Gender =
+    | 'female'
+    | 'male'
+    | 'other';
+
+export type HeadingLevel =
+    | 1
+    | 2
+    | 3
+    | 4
+    | 5
+    | 6;
+
+export type NoticeType =
+    | 'primary'
+    | 'danger'
+    | 'info'
+    | 'success'
+    | 'warning';

package/src/types/index.ts

@@ -0,0 +1,9 @@
+export type * from './auth';
+export type * from './general';
+export type * from './event';
+export type * from './finance';
+export type * from './order';
+export type * from './payment';
+export type * from './product';
+export type * from './publicShop';
+export type * from './ticket';

package/src/types/order.ts

@@ -0,0 +1,7 @@
+export type OrderOrigin =
+    | 'local'
+    | 'ticketswap';
+
+export type OrderType =
+    | 'default'
+    | 'guest';

package/src/types/payment.ts

@@ -0,0 +1,11 @@
+export type PaymentProviderType =
+    | 'mollie'
+    | 'manual';
+
+export type TransactionStatus =
+    | 'canceled'
+    | 'expired'
+    | 'failed'
+    | 'paid'
+    | 'pending'
+    | 'setup'

package/src/types/product.ts

@@ -0,0 +1,2 @@
+export type ProductType =
+    | 'ticket'

package/src/types/publicShop.ts

@@ -0,0 +1,7 @@
+export type PublicShopElementType =
+    | 'button'
+    | 'divider'
+    | 'heading'
+    | 'notice'
+    | 'product'
+    | 'text';

package/src/types/ticket.ts

@@ -0,0 +1,12 @@
+export type ScanStatus =
+    | 'checkin'
+    | 'checkout'
+    | 'expired'
+    | 'pending'
+    | 'upcoming';
+
+export type TicketValidity =
+    | 'valid'
+    | 'invalid'
+    | 'refunded'
+    | 'swapped';

package/src/util/emptyNull.ts

@@ -0,0 +1,9 @@
+export default function <T>(value: T): T | null {
+    if (typeof value === 'string' && value.trim().length === 0) {
+        return null;
+    } else if (Array.isArray(value) && value.length === 0) {
+        return null;
+    }
+
+    return value;
+}

package/src/util/index.ts

@@ -0,0 +1,4 @@
+export { default as emptyNull } from './emptyNull';
+export { default as jsonBlob } from './jsonBlob';
+export { default as optional } from './optional';
+export { default as optionalArray } from './optionalArray';

package/src/util/jsonBlob.ts

@@ -0,0 +1,5 @@
+export default function <T>(json: T): Blob {
+    return new Blob([JSON.stringify(json)], {
+        type: 'application/json'
+    });
+}

package/src/util/optional.ts

@@ -0,0 +1,7 @@
+export default function <T, U>(value: U, adapter: (value: U) => T): T {
+    if (value === undefined || value === null) {
+        return null as T;
+    }
+
+    return adapter(value);
+}

package/src/util/optionalArray.ts

@@ -0,0 +1,7 @@
+export default function <T>(value: object[], adapter: (value: object) => T): T[] | null {
+    if (value === undefined || value === null) {
+        return null;
+    }
+
+    return value.map(adapter);
+}