@passly-nl/data 0.1.0

package/src/adapter/EventAdapter.ts

@@ -0,0 +1,237 @@
+import { adapter } from '@basmilius/http-client';
+import { AddressAdapter, DateTimeAdapter, FileSystemAdapter, MerchantAdapter, PaymentAdapter, ProductAdapter } from '#data/adapter';
+import { EventAvailabilityDto, EventCountersDto, EventDto, EventStatisticsAttendanceDto, EventStatisticsBuyerTotalsDto, EventStatisticsFinancialDto, EventStatisticsOrdersDto, EventStatisticsOrderTotalsDto, EventStatisticsScansDto, EventStatisticsScansPerAppTeamDto, EventStatisticsScanTotalsDto, EventStatisticsSwapTotalsDto, ShopDesignDto, ShopDto, ShopElementButtonDto, ShopElementDividerDto, ShopElementDto, ShopElementHeadingDto, ShopElementNoticeDto, ShopElementProductDto, ShopElementTextDto, StockOverviewDto, StockOverviewItemDto, StockPoolDto, TicketTemplateDto } from '#data/dto';
+import { optional } from '#data/util';
+
+@adapter
+export class EventAdapter {
+    static parseEventFromObject(event: Record<string, any>): EventDto {
+        return new EventDto(
+            event.id,
+            event.name,
+            event.description,
+            DateTimeAdapter.parseDateTimeFromString(event.starts_on),
+            DateTimeAdapter.parseDateTimeFromString(event.ends_on),
+            event.minimum_age,
+            event.status,
+            optional(event.address, AddressAdapter.parseAddressFromObject)!,
+            optional(event.header_file, FileSystemAdapter.parsePictureFromObject)!,
+            DateTimeAdapter.parseDateTimeFromString(event.created_on),
+            DateTimeAdapter.parseDateTimeFromString(event.updated_on)
+        );
+    }
+
+    static parseEventAvailabilityFromObject(availability: Record<string, any>): EventAvailabilityDto {
+        return new EventAvailabilityDto(
+            availability.has_products,
+            availability.has_shops,
+            availability.has_shops_with_products,
+            availability.is_publishable,
+            availability.is_published
+        );
+    }
+
+    static parseEventCountersFromObject(counters: Record<string, any>): EventCountersDto {
+        return new EventCountersDto(
+            counters.guests,
+            counters.orders,
+            counters.tickets
+        );
+    }
+
+    static parseShopFromObject(shop: Record<string, any>): ShopDto {
+        return new ShopDto(
+            shop.id,
+            shop.name,
+            shop.is_published,
+            shop.password,
+            optional(shop.starts_on, DateTimeAdapter.parseDateTimeFromString),
+            optional(shop.ends_on, DateTimeAdapter.parseDateTimeFromString),
+            shop.field_address,
+            shop.field_birthdate,
+            shop.field_gender,
+            shop.field_phone_number,
+            shop.status,
+            optional(shop.design, EventAdapter.parseShopDesignFromObject),
+            optional(shop.event, EventAdapter.parseEventFromObject),
+            optional(shop.merchant, MerchantAdapter.parseMerchantFromObject)
+        );
+    }
+
+    static parseShopDesignFromObject(design: Record<string, any>): ShopDesignDto {
+        return new ShopDesignDto(
+            design.background_color,
+            design.foreground_color,
+            design.primary_color
+        );
+    }
+
+    static parseShopElementFromObject(element: Record<string, any>): ShopElementDto {
+        switch (element.type) {
+            case 'button':
+                return new ShopElementButtonDto(
+                    element.id,
+                    element.icon,
+                    element.text,
+                    element.url
+                );
+
+            case 'divider':
+                return new ShopElementDividerDto(
+                    element.id,
+                    element.icon,
+                    element.text
+                );
+
+            case 'heading':
+                return new ShopElementHeadingDto(
+                    element.id,
+                    element.heading_level,
+                    element.title
+                );
+
+            case 'notice':
+                return new ShopElementNoticeDto(
+                    element.id,
+                    element.icon,
+                    element.notice_type,
+                    element.title,
+                    element.text
+                );
+
+            case 'product':
+                return new ShopElementProductDto(
+                    element.id,
+                    ProductAdapter.parseProductFromObject(element.product)
+                );
+
+            case 'text':
+                return new ShopElementTextDto(
+                    element.id,
+                    element.text
+                );
+        }
+
+        return new ShopElementTextDto(
+            'unknown',
+            'Unknown element type.'
+        );
+    }
+
+    static parseStockOverviewFromObject(overview: Record<string, any>): StockOverviewDto {
+        return new StockOverviewDto(
+            overview.total,
+            overview.sold,
+            overview.remaining,
+            overview.items.map(EventAdapter.parseStockOverviewItemFromObject)
+        );
+    }
+
+    static parseStockOverviewItemFromObject(item: Record<string, any>): StockOverviewItemDto {
+        return new StockOverviewItemDto(
+            EventAdapter.parseStockPoolFromObject(item.pool),
+            ProductAdapter.parseProductFromObject(item.product),
+            item.remaining,
+            item.sold
+        );
+    }
+
+    static parseStockPoolFromObject(pool: Record<string, any>): StockPoolDto {
+        return new StockPoolDto(
+            pool.id,
+            pool.event_id,
+            pool.merchant_id,
+            pool.name,
+            pool.remaining_stock,
+            pool.stock,
+            pool.is_shared,
+            pool.product_names ?? [],
+            DateTimeAdapter.parseDateTimeFromString(pool.created_on),
+            DateTimeAdapter.parseDateTimeFromString(pool.updated_on)
+        );
+    }
+
+    static parseTicketTemplateFromObject(template: Record<string, any>): TicketTemplateDto {
+        return new TicketTemplateDto(
+            template.id,
+            template.name,
+            optional(template.product, ProductAdapter.parseProductFromObject),
+            template.product_id,
+            template.variant,
+            optional(template.visual, FileSystemAdapter.parsePictureFromObject)
+        );
+    }
+
+    static parseEventStatisticsAttendanceFromObject(attendance: Record<string, any>): EventStatisticsAttendanceDto {
+        return new EventStatisticsAttendanceDto(
+            attendance.attended,
+            attendance.expected,
+            attendance.rate
+        );
+    }
+
+    static parseEventStatisticsBuyerTotalsFromObject(totals: Record<string, any>): EventStatisticsBuyerTotalsDto {
+        return new EventStatisticsBuyerTotalsDto(
+            totals.acquired,
+            totals.average_tickets,
+            totals.doubting,
+            totals.returning,
+            totals.total
+        );
+    }
+
+    static parseEventStatisticsFinancialFromObject(financial: Record<string, any>): EventStatisticsFinancialDto {
+        return new EventStatisticsFinancialDto(
+            PaymentAdapter.parseCostFromObject(financial.platform_cost),
+            PaymentAdapter.parseCostFromObject(financial.revenue)
+        );
+    }
+
+    static parseEventStatisticsOrdersFromObject(totals: Record<string, any>): EventStatisticsOrdersDto {
+        return new EventStatisticsOrdersDto(
+            totals.chart,
+            EventAdapter.parseEventStatisticsOrderTotalsFromObject(totals.totals)
+        );
+    }
+
+    static parseEventStatisticsOrderTotalsFromObject(totals: Record<string, any>): EventStatisticsOrderTotalsDto {
+        return new EventStatisticsOrderTotalsDto(
+            totals.fulfilled,
+            totals.interrupted,
+            totals.pending,
+            totals.total
+        );
+    }
+
+    static parseEventStatisticsScansFromObject(scans: Record<string, any>): EventStatisticsScansDto {
+        return new EventStatisticsScansDto(
+            scans.app_teams.map(EventAdapter.parseEventStatisticsScansPerAppTeamFromObject),
+            scans.chart,
+            EventAdapter.parseEventStatisticsScanTotalsFromObject(scans.totals)
+        );
+    }
+
+    static parseEventStatisticsScansPerAppTeamFromObject(appTeam: Record<string, any>): EventStatisticsScansPerAppTeamDto {
+        return new EventStatisticsScansPerAppTeamDto(
+            appTeam.id,
+            appTeam.name,
+            appTeam.scans
+        );
+    }
+
+    static parseEventStatisticsScanTotalsFromObject(totals: Record<string, any>): EventStatisticsScanTotalsDto {
+        return new EventStatisticsScanTotalsDto(
+            totals.total,
+            totals.checkins,
+            totals.checkouts
+        );
+    }
+
+    static parseEventStatisticsSwapTotalsFromObject(totals: Record<string, any>): EventStatisticsSwapTotalsDto {
+        return new EventStatisticsSwapTotalsDto(
+            totals.swaps,
+            totals.tickets,
+            totals.rate
+        );
+    }
+}

package/src/adapter/FileSystemAdapter.ts

@@ -0,0 +1,13 @@
+import { adapter } from '@basmilius/http-client';
+import { PictureDto } from '#data/dto';
+
+@adapter
+export class FileSystemAdapter {
+    static parsePictureFromObject(picture: Record<string, any>): PictureDto {
+        return new PictureDto(
+            picture.id,
+            picture.url,
+            picture.variants
+        );
+    }
+}

package/src/adapter/FinanceAdapter.ts

@@ -0,0 +1,40 @@
+import { adapter } from '@basmilius/http-client';
+import { DateTimeAdapter, PaymentAdapter } from '#data/adapter';
+import { FinanceOverviewDto, InvoiceDto, InvoiceLineDto } from '#data/dto';
+import { optionalArray } from '#data/util';
+
+@adapter
+export class FinanceAdapter {
+    static parseFinanceOverviewFromObject(overview: Record<string, any>): FinanceOverviewDto {
+        return new FinanceOverviewDto(
+            PaymentAdapter.parseCostFromObject(overview.estimated_payment_cost),
+            overview.orders,
+            PaymentAdapter.parseCostFromObject(overview.platform_cost),
+            PaymentAdapter.parseCostFromObject(overview.revenue)
+        );
+    }
+
+    static parseInvoiceFromObject(invoice: Record<string, any>): InvoiceDto {
+        return new InvoiceDto(
+            invoice.id,
+            invoice.number,
+            invoice.sequence,
+            invoice.status,
+            invoice.year,
+            PaymentAdapter.parseCostFromObject(invoice.total),
+            optionalArray(invoice.lines, FinanceAdapter.parseInvoiceLineFromObject)!,
+            DateTimeAdapter.parseDateTimeFromString(invoice.created_on),
+            DateTimeAdapter.parseDateTimeFromString(invoice.updated_on)
+        );
+    }
+
+    static parseInvoiceLineFromObject(line: Record<string, any>): InvoiceLineDto {
+        return new InvoiceLineDto(
+            line.id,
+            line.type,
+            PaymentAdapter.parseCostFromObject(line.cost),
+            DateTimeAdapter.parseDateTimeFromString(line.created_on),
+            DateTimeAdapter.parseDateTimeFromString(line.updated_on)
+        );
+    }
+}

package/src/adapter/FluxAdapter.ts

@@ -0,0 +1,21 @@
+import { adapter } from '@basmilius/http-client';
+import type { FluxFormSelectEntry, FluxFormSelectGroup, FluxFormSelectOption } from '@flux-ui/types';
+
+@adapter
+export class FluxAdapter {
+    static parseFluxFormSelectEntryFromObject(entry: object): FluxFormSelectEntry {
+        if ('value' in entry) {
+            return FluxAdapter.parseFluxFormSelectOptionFromObject(entry);
+        }
+
+        return FluxAdapter.parseFluxFormSelectGroupFromObject(entry);
+    }
+
+    static parseFluxFormSelectGroupFromObject(group: object): FluxFormSelectGroup {
+        return group as FluxFormSelectGroup;
+    }
+
+    static parseFluxFormSelectOptionFromObject(option: object): FluxFormSelectOption {
+        return option as FluxFormSelectOption;
+    }
+}

package/src/adapter/MerchantAdapter.ts

@@ -0,0 +1,70 @@
+import { adapter } from '@basmilius/http-client';
+import { AddressAdapter, AuthAdapter, DateTimeAdapter, FileSystemAdapter, PaymentAdapter } from '#data/adapter';
+import { ContractDto, InvitationDto, MerchantDto, MerchantUserDto, VatNumberDto } from '#data/dto';
+import { optional } from '#data/util';
+
+@adapter
+export class MerchantAdapter {
+    static parseContractFromObject(contract: Record<string, any>): ContractDto {
+        return new ContractDto(
+            contract.id,
+            DateTimeAdapter.parseDateTimeFromString(contract.starts_on),
+            DateTimeAdapter.parseDateTimeFromString(contract.ends_on),
+            PaymentAdapter.parseCostFromObject(contract.fee),
+            contract.remark
+        );
+    }
+
+    static parseInvitationFromObject(invitation: Record<string, any>): InvitationDto {
+        return new InvitationDto(
+            invitation.id,
+            invitation.merchant_id,
+            invitation.user_id,
+            invitation.claims,
+            invitation.is_new_user,
+            DateTimeAdapter.parseDateTimeFromString(invitation.created_on),
+            DateTimeAdapter.parseDateTimeFromString(invitation.updated_on),
+            MerchantAdapter.parseMerchantFromObject(invitation.merchant),
+            AuthAdapter.parseUserFromObject(invitation.user)
+        );
+    }
+
+    static parseMerchantFromObject(merchant: Record<string, any>): MerchantDto {
+        return new MerchantDto(
+            merchant.id,
+            merchant.name,
+            merchant.email,
+            merchant.phone_number,
+            merchant.url,
+            merchant.chamber_of_commerce_number,
+            merchant.vat_number,
+            merchant.currency,
+            optional(merchant.address, AddressAdapter.parseAddressFromObject),
+            optional(merchant.current_contract, MerchantAdapter.parseContractFromObject),
+            optional(merchant.logo, FileSystemAdapter.parsePictureFromObject),
+            optional(merchant.created_on, DateTimeAdapter.parseDateTimeFromString),
+            optional(merchant.updated_on, DateTimeAdapter.parseDateTimeFromString)
+        );
+    }
+
+    static parseMerchantUserFromObject(merchantUser: Record<string, any>): MerchantUserDto {
+        return new MerchantUserDto(
+            merchantUser.is_manager,
+            DateTimeAdapter.parseDateTimeFromString(merchantUser.created_on),
+            DateTimeAdapter.parseDateTimeFromString(merchantUser.updated_on),
+            AuthAdapter.parseUserFromObject(merchantUser.user)
+        );
+    }
+
+    static parseVatNumberFromObject(vatNumber: Record<string, any>): VatNumberDto {
+        return new VatNumberDto(
+            vatNumber.id,
+            vatNumber.vat_number,
+            vatNumber.name,
+            vatNumber.address,
+            vatNumber.country_code,
+            DateTimeAdapter.parseDateTimeFromString(vatNumber.created_on),
+            DateTimeAdapter.parseDateTimeFromString(vatNumber.updated_on)
+        );
+    }
+}

package/src/adapter/MerchantDashboardAdapter.ts

@@ -0,0 +1,29 @@
+import { adapter } from '@basmilius/http-client';
+import { DateTimeAdapter, FileSystemAdapter } from '#data/adapter';
+import { MerchantDashboardKeyMetricsDto, MerchantDashboardUpcomingEventDto } from '#data/dto';
+
+@adapter
+export class MerchantDashboardAdapter {
+    static parseKeyMetricsFromObject(keyMetrics: Record<string, any>): MerchantDashboardKeyMetricsDto {
+        return new MerchantDashboardKeyMetricsDto(
+            keyMetrics.revenue,
+            keyMetrics.tickets,
+            keyMetrics.events,
+            keyMetrics.tasks
+        );
+    }
+
+    static parseUpcomingEventFromObject(event: Record<string, any>): MerchantDashboardUpcomingEventDto {
+        return new MerchantDashboardUpcomingEventDto(
+            event.id,
+            event.name,
+            event.description,
+            FileSystemAdapter.parsePictureFromObject(event.header_file),
+            event.status,
+            DateTimeAdapter.parseDateTimeFromString(event.starts_on),
+            event.tickets_sold,
+            event.tickets_total,
+            event.sell_through_rate
+        );
+    }
+}

package/src/adapter/OrderAdapter.ts

@@ -0,0 +1,55 @@
+import { adapter } from '@basmilius/http-client';
+import { BuyerAdapter, DateTimeAdapter, EventAdapter, PaymentAdapter, PublicShopAdapter } from '#data/adapter';
+import { OrderDto, OrderLineDto, OrderPaymentProviderDto, OrderProductDto } from '#data/dto';
+import { optional, optionalArray } from '#data/util';
+
+@adapter
+export class OrderAdapter {
+    static parseOrderFromObject(order: Record<string, any>): OrderDto {
+        return new OrderDto(
+            order.id,
+            order.code,
+            order.origin,
+            order.type,
+            DateTimeAdapter.parseDateTimeFromString(order.created_on),
+            optional(order.payment_provider, OrderAdapter.parseOrderPaymentProviderFromObject),
+            optional(order.platform_cost, PaymentAdapter.parseCostFromObject)!,
+            optional(order.sub_total, PaymentAdapter.parseCostFromObject)!,
+            optional(order.total, PaymentAdapter.parseCostFromObject)!,
+            order.url,
+            optional(order.buyer, BuyerAdapter.parseBuyerFromObject),
+            optional(order.event, EventAdapter.parseEventFromObject),
+            optionalArray(order.lines, OrderAdapter.parseOrderLineFromObject),
+            optional(order.shop, PublicShopAdapter.parsePublicShopFromObject),
+            optional(order.transaction, PaymentAdapter.parseTransactionFromObject)
+        );
+    }
+
+    static parseOrderLineFromObject(line: Record<string, any>): OrderLineDto {
+        return new OrderLineDto(
+            line.id,
+            PaymentAdapter.parseCostFromObject(line.price),
+            line.quantity,
+            OrderAdapter.parseOrderProductFromObject(line.product),
+            PaymentAdapter.parseCostFromObject(line.sub_total),
+            DateTimeAdapter.parseDateTimeFromString(line.created_on),
+            DateTimeAdapter.parseDateTimeFromString(line.updated_on)
+        );
+    }
+
+    static parseOrderPaymentProviderFromObject(provider: Record<string, any>): OrderPaymentProviderDto {
+        return new OrderPaymentProviderDto(
+            provider.name,
+            provider.url
+        );
+    }
+
+    static parseOrderProductFromObject(product: Record<string, any>): OrderProductDto {
+        return new OrderProductDto(
+            product.id,
+            product.name,
+            product.description,
+            product.image
+        );
+    }
+}

package/src/adapter/PaymentAdapter.ts

@@ -0,0 +1,48 @@
+import { adapter } from '@basmilius/http-client';
+import { OrderAdapter } from '#data/adapter';
+import { CostDto, PaymentMethodDto, PaymentProviderDto, TransactionDto } from '#data/dto';
+import { optional } from '#data/util';
+
+@adapter
+export class PaymentAdapter {
+    static parseCostFromObject(cost: Record<string, any>): CostDto {
+        return new CostDto(
+            cost.currency_code,
+            cost.currency_decimals,
+            cost.currency_sign,
+            cost.decimal,
+            cost.formatted,
+            cost.value
+        );
+    }
+
+    static parsePaymentMethodFromObject(method: Record<string, any>): PaymentMethodDto {
+        return new PaymentMethodDto(
+            method.id,
+            method.name,
+            method.image
+        );
+    }
+
+    static parsePaymentProviderFromObject(provider: Record<string, any>): PaymentProviderDto {
+        return new PaymentProviderDto(
+            provider.id,
+            provider.type,
+            provider.methods.map(PaymentAdapter.parsePaymentMethodFromObject)
+        );
+    }
+
+    static parseTransactionFromObject(transaction: Record<string, any>): TransactionDto {
+        return new TransactionDto(
+            transaction.id,
+            transaction.description,
+            transaction.status,
+            PaymentAdapter.parseCostFromObject(transaction.cost),
+            transaction.metadata,
+            transaction.external_checkout_url,
+            transaction.external_details,
+            optional(transaction.order, OrderAdapter.parseOrderFromObject),
+            optional(transaction.payment_method, PaymentAdapter.parsePaymentMethodFromObject)
+        );
+    }
+}

package/src/adapter/ProductAdapter.ts

@@ -0,0 +1,24 @@
+import { adapter } from '@basmilius/http-client';
+import { EventAdapter, FileSystemAdapter, PaymentAdapter } from '#data/adapter';
+import { ProductDto } from '#data/dto';
+import { optional, optionalArray } from '#data/util';
+
+@adapter
+export class ProductAdapter {
+    static parseProductFromObject(product: Record<string, any>): ProductDto {
+        return new ProductDto(
+            product.id,
+            product.type,
+            product.name,
+            product.description,
+            optional(product.price, PaymentAdapter.parseCostFromObject),
+            product.max_quantity,
+            product.is_active,
+            product.is_swappable,
+            product.remaining_stock,
+            optional(product.stock_pool, EventAdapter.parseStockPoolFromObject),
+            optional(product.image, FileSystemAdapter.parsePictureFromObject),
+            optionalArray(product.images, FileSystemAdapter.parsePictureFromObject)!
+        );
+    }
+}

package/src/adapter/PublicPayAdapter.ts

@@ -0,0 +1,13 @@
+import { adapter } from '@basmilius/http-client';
+import { PublicPaymentMethodDto } from '#data/dto';
+
+@adapter
+export class PublicPayAdapter {
+    static parsePublicPaymentMethodFromObject(method: Record<string, any>): PublicPaymentMethodDto {
+        return new PublicPaymentMethodDto(
+            method.id,
+            method.name,
+            method.image
+        );
+    }
+}