@dascompany/product 4.5.1 → 4.5.2

package/dist/stockObjects/Status.js

@@ -0,0 +1,42 @@
+import { StockObject } from "@dascompany/database";
+import StatusMapper from "../mappers/StatusMapper";
+export default class Status extends StockObject {
+    orderId;
+    userId;
+    type;
+    createdAt;
+    constructor(orderId, userId, type, createdAt = null) {
+        super();
+        this.orderId = orderId;
+        this.userId = userId;
+        this.type = type;
+        this.createdAt = createdAt;
+    }
+    getOrderId() {
+        return this.orderId;
+    }
+    getCreatedAt() {
+        return this.createdAt;
+    }
+    getUserId() {
+        return this.userId;
+    }
+    getType() {
+        return this.type;
+    }
+    setOrderId(orderId) {
+        this.orderId = orderId;
+    }
+    setCreatedAt(createdAt) {
+        this.createdAt = createdAt;
+    }
+    setUserId(userId) {
+        this.userId = userId;
+    }
+    setType(type) {
+        this.type = type;
+    }
+    getMapper() {
+        return new StatusMapper(this);
+    }
+}

package/dist/tables/TableNames.d.ts

@@ -0,0 +1,28 @@
+declare enum TableNames {
+    adminAccounts = "adminAccountsTable",
+    clientAccounts = "clientAccountsTable",
+    accountDeliveryDetails = "accountDeliveryDetailsTable",
+    accountCart = "accountCartTable",
+    accountCompanyDetails = "accountCompanyDetailsTable",
+    fileConnections = "fileConnectionsTable",
+    files = "filesTable",
+    ordersProducts = "ordersProductsTable",
+    orders = "ordersTable",
+    paymentDetails = "paymentDetailsTable",
+    paymentStatuses = "paymentStatusesTable",
+    paymentStatusTypes = "paymentStatusTypesTable",
+    statuses = "statusesTable",
+    statusTypes = "statusTypesTable",
+    addresses = "addressesTable",
+    companyDetails = "companyDetailsTable",
+    deliveryDetails = "deliveryDetailsTable",
+    deliveryStatuses = "deliveryStatusesTable",
+    deliveryStatusTypes = "deliveryStatusTypesTable",
+    personalData = "personalDataTable",
+    products = "productsTable",
+    companyData = "companyDataTable",
+    deliveryMethods = "deliveryMethodsTable",
+    paymentMethods = "paymentMethodsTable",
+    marketPlaces = "marketPlacesTable"
+}
+export default TableNames;

package/dist/tables/TableNames.js

@@ -0,0 +1,29 @@
+var TableNames;
+(function (TableNames) {
+    TableNames["adminAccounts"] = "adminAccountsTable";
+    TableNames["clientAccounts"] = "clientAccountsTable";
+    TableNames["accountDeliveryDetails"] = "accountDeliveryDetailsTable";
+    TableNames["accountCart"] = "accountCartTable";
+    TableNames["accountCompanyDetails"] = "accountCompanyDetailsTable";
+    TableNames["fileConnections"] = "fileConnectionsTable";
+    TableNames["files"] = "filesTable";
+    TableNames["ordersProducts"] = "ordersProductsTable";
+    TableNames["orders"] = "ordersTable";
+    TableNames["paymentDetails"] = "paymentDetailsTable";
+    TableNames["paymentStatuses"] = "paymentStatusesTable";
+    TableNames["paymentStatusTypes"] = "paymentStatusTypesTable";
+    TableNames["statuses"] = "statusesTable";
+    TableNames["statusTypes"] = "statusTypesTable";
+    TableNames["addresses"] = "addressesTable";
+    TableNames["companyDetails"] = "companyDetailsTable";
+    TableNames["deliveryDetails"] = "deliveryDetailsTable";
+    TableNames["deliveryStatuses"] = "deliveryStatusesTable";
+    TableNames["deliveryStatusTypes"] = "deliveryStatusTypesTable";
+    TableNames["personalData"] = "personalDataTable";
+    TableNames["products"] = "productsTable";
+    TableNames["companyData"] = "companyDataTable";
+    TableNames["deliveryMethods"] = "deliveryMethodsTable";
+    TableNames["paymentMethods"] = "paymentMethodsTable";
+    TableNames["marketPlaces"] = "marketPlacesTable";
+})(TableNames || (TableNames = {}));
+export default TableNames;

package/dist/tables/clients/AccountCartTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import AccountCartRow from '../../types/rows/AccountCartRow';
+import AccountCartItem from '../../stockObjects/AccountCartItem.ts';
+export default class AccountCartTable extends Table {
+    select(queryOptions: QueryOptions): Promise<AccountCartRow[]>;
+    delete(queryOptions: QueryOptions): Promise<void>;
+    insert(accountCartItem: AccountCartItem): Promise<void>;
+    update(accountCartItem: AccountCartItem): Promise<void>;
+    private bindParams;
+    private bindSideParams;
+}

package/dist/tables/clients/AccountCartTable.js

@@ -0,0 +1,35 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class AccountCartTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.accountCart.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async delete(queryOptions) {
+        const query = this.createQuery(SQL.accountCart.delete, queryOptions);
+        await query.execute();
+    }
+    async insert(accountCartItem) {
+        const query = this.createQuery(SQL.accountCart.insert);
+        this.bindParams(query, accountCartItem.getAccountId(), accountCartItem.getProductId());
+        this.bindSideParams(query, accountCartItem);
+        await query.execute();
+    }
+    async update(accountCartItem) {
+        const query = this.createQuery(SQL.accountCart.update);
+        query.bindParameter('account_id', accountCartItem.getAccountId());
+        query.bindParameter('product_id', accountCartItem.getProductId());
+        query.bindParameter('installation', accountCartItem.getInstallation());
+        query.bindParameter('quantity', accountCartItem.getQuantity());
+        await query.execute();
+    }
+    bindParams(query, accountId, productId) {
+        query.bindParameter('account_id', accountId);
+        query.bindParameter('product_id', productId);
+    }
+    bindSideParams(query, accountCartItem) {
+        query.bindParameter('installation', accountCartItem.getInstallation());
+        query.bindParameter('quantity', accountCartItem.getQuantity());
+    }
+}

package/dist/tables/clients/AccountCompanyDetailsTable.d.ts

@@ -0,0 +1,7 @@
+import { Table } from '@dascompany/database';
+import AccountCompanyDetailsRow from '../../types/rows/AccountCompanyDetailsRow';
+export default class AccountCompanyDetailsTable extends Table {
+    selectAll(accountId: number): Promise<AccountCompanyDetailsRow[]>;
+    delete(companyDetailsId: string): Promise<number>;
+    insert(acoountId: string, companyDetailsId: string): Promise<void>;
+}

package/dist/tables/clients/AccountCompanyDetailsTable.js

@@ -0,0 +1,22 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class AccountCompanyDetailsTable extends Table {
+    async selectAll(accountId) {
+        const query = this.createQuery(SQL.accountCompanyDetails.select);
+        query.bindParameter('account_id', accountId);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async delete(companyDetailsId) {
+        const query = this.createQuery(SQL.accountCompanyDetails.delete);
+        query.bindParameter('company_details_id', companyDetailsId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    async insert(acoountId, companyDetailsId) {
+        const query = this.createQuery(SQL.accountCompanyDetails.insert);
+        query.bindParameter('company_details_id', companyDetailsId);
+        query.bindParameter('account_id', acoountId);
+        await query.execute();
+    }
+}

package/dist/tables/clients/AccountDeliveryDetailsTable.d.ts

@@ -0,0 +1,7 @@
+import { Table } from '@dascompany/database';
+import AccountDeliveryDetailsRow from '../../types/rows/AccountDeliveryDetailsRow';
+export default class AccountDeliveryDetailsTable extends Table {
+    selectAll(accountId: number): Promise<AccountDeliveryDetailsRow[]>;
+    delete(deliveryDetailsId: string): Promise<number>;
+    insert(acoountId: string, deliveryDetailsId: string): Promise<void>;
+}

package/dist/tables/clients/AccountDeliveryDetailsTable.js

@@ -0,0 +1,22 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class AccountDeliveryDetailsTable extends Table {
+    async selectAll(accountId) {
+        const query = this.createQuery(SQL.accountDeliveryDetails.select);
+        query.bindParameter('account_id', accountId);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async delete(deliveryDetailsId) {
+        const query = this.createQuery(SQL.accountDeliveryDetails.delete);
+        query.bindParameter('delivery_details_id', deliveryDetailsId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    async insert(acoountId, deliveryDetailsId) {
+        const query = this.createQuery(SQL.accountDeliveryDetails.insert);
+        query.bindParameter('delivery_details_id', deliveryDetailsId);
+        query.bindParameter('account_id', acoountId);
+        await query.execute();
+    }
+}

package/dist/tables/clients/ClientAccountsTable.d.ts

@@ -0,0 +1,14 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import ClientAccountRow from '../../types/rows/ClientAccountRow';
+import Client from '../../stockObjects/Client';
+export default class ClientAccountsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<ClientAccountRow>;
+    selectAll(queryOptions?: QueryOptions): Promise<ClientAccountRow[]>;
+    selectId(queryOptions: QueryOptions): Promise<string | null>;
+    count(queryOptions: QueryOptions): Promise<number>;
+    update(clientData: Client): Promise<void>;
+    delete(accountId: string): Promise<number>;
+    private bindParameters;
+    insert(clientAccount: Client): Promise<void>;
+    private selectNextId;
+}

package/dist/tables/clients/ClientAccountsTable.js

@@ -0,0 +1,65 @@
+import { ParameterType, QueryOptions, Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+import CilentAccountExistWithThisEmail from '../../lib/errors/CilentAccountExistWithThisEmail';
+export default class ClientAccountsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.accounts.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.accounts.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.accounts.selectId, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async count(queryOptions) {
+        const query = this.createQuery(SQL.accounts.count, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async update(clientData) {
+        const query = this.createQuery(SQL.accounts.update);
+        query.bindParameter('id', clientData.getId());
+        this.bindParameters(query, clientData);
+        await query.execute();
+    }
+    async delete(accountId) {
+        const query = this.createQuery(SQL.accounts.delete);
+        query.bindParameter('account_id', accountId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    bindParameters(query, clientAccount) {
+        query.bindParameter('activated', clientAccount.getActivated());
+        query.bindParameter('deleted', clientAccount.getDeleted());
+        query.bindParameter('personal_data_id', clientAccount.getPersonalDataId());
+        query.bindParameter('delivery_details_id', clientAccount.getDeliveryDetailsId());
+        query.bindParameter('company_details_id', clientAccount.getCompanyDetailsId());
+    }
+    async insert(clientAccount) {
+        const clientEmail = clientAccount.getEmail();
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'email', type: ParameterType.string, value: clientEmail }]);
+        let accountId = await this.selectId(queryOptions);
+        if (accountId)
+            throw new CilentAccountExistWithThisEmail(clientEmail);
+        else
+            accountId = await this.selectNextId();
+        const query = this.createQuery(SQL.accounts.insert);
+        query.bindParameter('id', accountId);
+        query.bindParameter('email', clientEmail);
+        this.bindParameters(query, clientAccount);
+        await query.execute();
+        clientAccount.setId(accountId);
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.accounts.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/files/FileConnectionsTable.d.ts

@@ -0,0 +1,9 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import FileConnection from '../../stockObjects/FileConnection';
+import FileConnectionRow from '../../types/rows/FileConnectionRow';
+export default class FileConnectionsTable extends Table {
+    selectAll(queryOptions?: QueryOptions): Promise<FileConnectionRow[]>;
+    insert(fileConnection: FileConnection): Promise<void>;
+    delete(queryOptions: QueryOptions): Promise<boolean>;
+    private bindParameters;
+}

package/dist/tables/files/FileConnectionsTable.js

@@ -0,0 +1,25 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class FileConnectionsTable extends Table {
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.fileConnections.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(fileConnection) {
+        const query = this.createQuery(SQL.fileConnections.insert);
+        this.bindParameters(query, fileConnection);
+        await query.execute();
+    }
+    async delete(queryOptions) {
+        const query = this.createQuery(SQL.fileConnections.delete, queryOptions);
+        await query.execute();
+        return true;
+    }
+    bindParameters(query, fileConnection) {
+        query.bindParameter('file_id', fileConnection.getFileId());
+        query.bindParameter('connection_type', fileConnection.getConnectionType());
+        query.bindParameter('connection_id', fileConnection.getConnectionId());
+        query.bindParameter('sequence', fileConnection.getSequence());
+    }
+}

package/dist/tables/files/FilesTable.d.ts

@@ -0,0 +1,15 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import FileRow from '../../types/rows/FileRow';
+import File from '../../stockObjects/File';
+export default class FilesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<FileRow>;
+    selectAll(queryOptions?: QueryOptions): Promise<FileRow[]>;
+    selectId(queryOptions: QueryOptions): Promise<string>;
+    selectForConnection(queryOptions: QueryOptions): Promise<FileRow[]>;
+    insert(file: File): Promise<boolean>;
+    update(fileData: File): Promise<boolean>;
+    count(queryOptions: QueryOptions): Promise<number>;
+    private bindParameters;
+    delete(fileId: string): Promise<number>;
+    private selectNextId;
+}

package/dist/tables/files/FilesTable.js

@@ -0,0 +1,65 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class FilesTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.files.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.files.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.files.selectId, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async selectForConnection(queryOptions) {
+        const query = this.createQuery(SQL.files.selectForConnection, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(file) {
+        const query = this.createQuery(SQL.files.insert);
+        const id = await this.selectNextId();
+        query.bindParameter('id', id);
+        this.bindParameters(query, file);
+        await query.execute();
+        file.setId(id);
+        return true;
+    }
+    async update(fileData) {
+        const query = this.createQuery(SQL.files.update);
+        query.bindParameter('id', fileData.getId());
+        this.bindParameters(query, fileData);
+        await query.execute();
+        return true;
+    }
+    async count(queryOptions) {
+        const query = this.createQuery(SQL.files.count, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, file) {
+        query.bindParameter('name', file.getName());
+        query.bindParameter('orginal_name', file.getOrginalName());
+        query.bindParameter('catalog', file.getCatalog());
+        query.bindParameter('size_kb', file.getSizeKb());
+        query.bindParameter('type', file.getType());
+        query.bindParameter('alt', file.getAlt());
+        query.bindParameter('title', file.getTitle());
+    }
+    async delete(fileId) {
+        const query = this.createQuery(SQL.files.delete);
+        query.bindParameter('file_id', fileId);
+        const response = await query.execute();
+        return response.getRowCount();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.files.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/orders/OrdersProductsTable.d.ts

@@ -0,0 +1,10 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import OrderProductRow from '../../types/rows/OrderProductRow';
+import OrderProduct from '../../stockObjects/OrderProduct';
+export default class OrdersProductsTable extends Table {
+    selectAll(queryOptions?: QueryOptions): Promise<OrderProductRow[]>;
+    insert(orderProduct: OrderProduct): Promise<boolean>;
+    delete(id: string): Promise<boolean>;
+    private selectNextId;
+    private bindParams;
+}

package/dist/tables/orders/OrdersProductsTable.js

@@ -0,0 +1,36 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class OrdersProductsTable extends Table {
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.ordersProducts.selectAll, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(orderProduct) {
+        const query = this.createQuery(SQL.ordersProducts.insert);
+        const id = await this.selectNextId();
+        query.bindParameter('id', id);
+        this.bindParams(query, orderProduct);
+        await query.execute();
+        orderProduct.setId(id);
+        return true;
+    }
+    async delete(id) {
+        const query = this.createQuery(SQL.ordersProducts.delete);
+        query.bindParameter('id', id);
+        await query.execute();
+        return true;
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.ordersProducts.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParams(query, orderProduct) {
+        query.bindParameter('order_id', orderProduct.getOrderId());
+        query.bindParameter('product_id', orderProduct.getProductId());
+        query.bindParameter('net_price', orderProduct.getNetPrice());
+        query.bindParameter('in_order', orderProduct.getInOrder());
+        query.bindParameter('installation_price', orderProduct.getInstallationPrice());
+    }
+}

package/dist/tables/orders/OrdersTable.d.ts

@@ -0,0 +1,13 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import OrderRow from '../../types/rows/OrderRow';
+import Order from '../../stockObjects/Order';
+export default class OrdersTable extends Table {
+    select(queryOptions: QueryOptions): Promise<OrderRow>;
+    selectAll(queryOption?: QueryOptions): Promise<OrderRow[]>;
+    count(queryOptions?: QueryOptions): Promise<number>;
+    insert(order: Order): Promise<void>;
+    update(order: Order): Promise<void>;
+    private bindParameters;
+    private bindDetailsParameters;
+    private selectNextId;
+}

package/dist/tables/orders/OrdersTable.js

@@ -0,0 +1,54 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class OrdersTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.orders.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOption) {
+        const query = this.createQuery(SQL.orders.select, queryOption);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async count(queryOptions) {
+        const query = this.createQuery(SQL.orders.count, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async insert(order) {
+        const orderId = await this.selectNextId();
+        const query = this.createQuery(SQL.orders.insert);
+        query.bindParameter('order_id', orderId);
+        this.bindParameters(query, order);
+        await query.execute();
+        order.setId(orderId);
+    }
+    async update(order) {
+        const orderId = order.getId();
+        const query = this.createQuery(SQL.orders.update);
+        query.bindParameter('id', orderId);
+        query.bindParameter('net_price', order.getNetPrice());
+        query.bindParameter('zsi_id', order.getZsiId());
+        this.bindDetailsParameters(query, order);
+        await query.execute();
+    }
+    bindParameters(query, order) {
+        query.bindParameter('email', order.getEmail());
+        query.bindParameter('net_price', order.getNetPrice());
+        query.bindParameter('client_id', order.getClientId());
+        this.bindDetailsParameters(query, order);
+    }
+    bindDetailsParameters(query, order) {
+        query.bindParameter('invoice', order.isInvoice());
+        query.bindParameter('vat', order.getVat());
+        query.bindParameter('delivery_details_id', order.getDeliveryDetailsId());
+        query.bindParameter('company_details_id', order.getCompanyDetailsId());
+        query.bindParameter('payment_details_id', order.getPaymentDetailsId());
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.orders.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/orders/PaymentDetailsTable.d.ts

@@ -0,0 +1,10 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import PaymentDetailsRow from '../../types/rows/PaymentDetailsRow';
+import PaymentDetails from '../../stockObjects/PaymentDetails';
+export default class PaymentDetailsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<PaymentDetailsRow>;
+    insert(paymentDetails: PaymentDetails): Promise<void>;
+    update(paymentDetails: PaymentDetails): Promise<void>;
+    private selectNextId;
+    private bindParameters;
+}

package/dist/tables/orders/PaymentDetailsTable.js

@@ -0,0 +1,33 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class PaymentDetailsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.paymentDetails.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async insert(paymentDetails) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.paymentDetails.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, paymentDetails);
+        await query.execute();
+        paymentDetails.setId(id);
+    }
+    async update(paymentDetails) {
+        const id = paymentDetails.getId();
+        const query = this.createQuery(SQL.paymentDetails.update);
+        query.bindParameter('id', id);
+        this.bindParameters(query, paymentDetails);
+        await query.execute();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.paymentDetails.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, paymentDetails) {
+        query.bindParameter('payment_method_id', paymentDetails.getPaymentMethodId());
+        query.bindParameter('payment_order_id', paymentDetails.getPaymentOrderId());
+    }
+}

package/dist/tables/orders/PaymentStatusTypesTable.d.ts

@@ -0,0 +1,7 @@
+import { QueryOptions, Table } from '@dascompany/database';
+export default class PaymentStatusTypesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<{
+        id: number;
+        value: string;
+    }>;
+}

package/dist/tables/orders/PaymentStatusTypesTable.js

@@ -0,0 +1,9 @@
+import * as SQL from '../../SQL.json';
+import { Table } from '@dascompany/database';
+export default class PaymentStatusTypesTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.paymentStatusTypes.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+}

package/dist/tables/orders/PaymentStatusesTable.d.ts

@@ -0,0 +1,9 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import PaymentStatus from '../../stockObjects/PaymentStatus';
+import PaymentStatusRow from '../../types/rows/PaymentStatusRow';
+export default class PaymentStatusesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<PaymentStatusRow>;
+    selectAll(queryOptions?: QueryOptions): Promise<PaymentStatusRow[]>;
+    insert(paymentStatus: PaymentStatus): Promise<void>;
+    private selectNextId;
+}

package/dist/tables/orders/PaymentStatusesTable.js

@@ -0,0 +1,28 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class PaymentStatusesTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.paymentStatuses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.paymentStatuses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(paymentStatus) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.paymentStatuses.insert);
+        query.bindParameter('id', id);
+        query.bindParameter('payment_details_id', paymentStatus.getPaymentDetailsId());
+        query.bindParameter('payment_status_type_id', paymentStatus.getPaymentStatusTypeId());
+        await query.execute();
+        paymentStatus.setId(id);
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.paymentStatuses.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/orders/StatusTypesTable.d.ts

@@ -0,0 +1,8 @@
+import { QueryOptions, Table } from '@dascompany/database';
+export default class StatusTypesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<{
+        id: string;
+        key: string;
+    }>;
+    selectAll(queryOptions?: QueryOptions): Promise<any[]>;
+}