@dascompany/product 4.5.1 → 4.5.2

package/dist/tables/orders/StatusTypesTable.js

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

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

@@ -0,0 +1,10 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import Status from '../../stockObjects/Status';
+import StatusRow from '../../types/rows/StatusRow';
+export default class StatusesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<StatusRow>;
+    selectAll(queryOptions?: QueryOptions): Promise<StatusRow[]>;
+    insert(status: Status): Promise<void>;
+    private bindParameters;
+    private selectNextId;
+}

package/dist/tables/orders/StatusesTable.js

@@ -0,0 +1,32 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class StatusesTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.statuses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.statuses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(status) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.statuses.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, status);
+        await query.execute();
+        status.setId(id);
+    }
+    bindParameters(query, status) {
+        query.bindParameter('order_id', status.getOrderId());
+        query.bindParameter('user_id', status.getUserId());
+        query.bindParameter('type', status.getType());
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.statuses.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/personalInformation/AddressesTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import Address from '../../stockObjects/Address';
+import AddressRow from '../../types/rows/AddressRow';
+export default class AddressesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<AddressRow>;
+    update(addressData: Address): Promise<void>;
+    insert(address: Address): Promise<void>;
+    private selectNextId;
+    delete(id: string): Promise<void>;
+    private bindParameters;
+}

package/dist/tables/personalInformation/AddressesTable.js

@@ -0,0 +1,41 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class AddressesTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.addresses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async update(addressData) {
+        const query = this.createQuery(SQL.addresses.update);
+        query.bindParameter('id', addressData.getId());
+        this.bindParameters(query, addressData);
+        await query.execute();
+    }
+    async insert(address) {
+        const query = this.createQuery(SQL.addresses.insert);
+        const id = await this.selectNextId();
+        query.bindParameter('id', id);
+        this.bindParameters(query, address);
+        await query.execute();
+        address.setId(id);
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.addresses.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async delete(id) {
+        const query = this.createQuery(SQL.addresses.delete);
+        query.bindParameter('id', id);
+        await query.execute();
+    }
+    bindParameters(query, address) {
+        query.bindParameter('country', address.getCountry());
+        query.bindParameter('city', address.getCity());
+        query.bindParameter('postal_code', address.getPostalCode());
+        query.bindParameter('street', address.getStreet());
+        query.bindParameter('house_number', address.getHouseNumber());
+        query.bindParameter('apartment_number', address.getApartmentNumber());
+    }
+}

package/dist/tables/personalInformation/CompanyDetailsTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import CompanyDetails from '../../stockObjects/CompanyDetails';
+import CompanyDetailsRow from '../../types/rows/CompanyDetailsRow';
+export default class CompanyDetailsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<CompanyDetailsRow>;
+    update(companyDetails: CompanyDetails): Promise<void>;
+    insert(companyDetails: CompanyDetails): Promise<void>;
+    delete(id: string): Promise<void>;
+    private selectNextId;
+    private bindParameters;
+}

package/dist/tables/personalInformation/CompanyDetailsTable.js

@@ -0,0 +1,38 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class CompanyDetailsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.companyDetails.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async update(companyDetails) {
+        const query = this.createQuery(SQL.companyDetails.update);
+        query.bindParameter('id', companyDetails.getId());
+        this.bindParameters(query, companyDetails);
+        await query.execute();
+    }
+    async insert(companyDetails) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.companyDetails.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, companyDetails);
+        await query.execute();
+        companyDetails.setId(id);
+    }
+    async delete(id) {
+        const query = this.createQuery(SQL.companyDetails.delete);
+        query.bindParameter('id', id);
+        await query.execute();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.companyDetails.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, companyDetails) {
+        query.bindParameter('name', companyDetails.getName());
+        query.bindParameter('tax_number', companyDetails.getTaxNumber());
+        query.bindParameter('address_id', companyDetails.getAddressId());
+    }
+}

package/dist/tables/personalInformation/DeliveryDetailsTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import DeliveryDetails from '../../stockObjects/DeliveryDetails';
+import DeliveryDetailsRow from '../../types/rows/DeliveryDetailsRow';
+export default class DeliveryDetailsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<DeliveryDetailsRow>;
+    insert(deliveryDetails: DeliveryDetails): Promise<void>;
+    update(deliveryDetails: DeliveryDetails): Promise<void>;
+    delete(id: string): Promise<void>;
+    private selectNextId;
+    private bindParameters;
+}

package/dist/tables/personalInformation/DeliveryDetailsTable.js

@@ -0,0 +1,39 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class DeliveryDetailsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.deliveryDetails.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async insert(deliveryDetails) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.deliveryDetails.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, deliveryDetails);
+        await query.execute();
+        deliveryDetails.setId(id);
+    }
+    async update(deliveryDetails) {
+        const id = deliveryDetails.getId();
+        const query = this.createQuery(SQL.deliveryDetails.update);
+        query.bindParameter('id', id);
+        this.bindParameters(query, deliveryDetails);
+        await query.execute();
+    }
+    async delete(id) {
+        const query = this.createQuery(SQL.deliveryDetails.delete);
+        query.bindParameter('id', id);
+        await query.execute();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.deliveryDetails.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, deliveryDetails) {
+        query.bindParameter('personal_data_id', deliveryDetails.getPersonalDataId());
+        query.bindParameter('address_id', deliveryDetails.getAddressId());
+        query.bindParameter('delivery_method_id', deliveryDetails.getDeliveryMethodId());
+    }
+}

package/dist/tables/personalInformation/DeliveryStatusTypesTable.d.ts

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

package/dist/tables/personalInformation/DeliveryStatusTypesTable.js

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

package/dist/tables/personalInformation/DeliveryStatusesTable.d.ts

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

package/dist/tables/personalInformation/DeliveryStatusesTable.js

@@ -0,0 +1,29 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class DeliveryStatusesTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.deliveryStatuses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.deliveryStatuses.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(deliveryStatus) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.deliveryStatuses.insert);
+        query.bindParameter('id', id);
+        query.bindParameter('delivery_details_id', deliveryStatus.getDeliveryDetailsId());
+        query.bindParameter('delivery_status_type_id', deliveryStatus.getDeliveryStatusTypeId());
+        query.bindParameter('user_id', deliveryStatus.getUserId());
+        await query.execute();
+        deliveryStatus.setId(id);
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.deliveryStatuses.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/personalInformation/PersonalDataTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import PersonalData from '../../stockObjects/PersonalData';
+import PersonalDataRow from '../../types/rows/PersonalDataRow';
+export default class PersonalDataTable extends Table {
+    select(queryOptions: QueryOptions): Promise<PersonalDataRow>;
+    insert(personalData: PersonalData): Promise<void>;
+    update(personalData: PersonalData): Promise<void>;
+    private selectNextId;
+    delete(id: string): Promise<void>;
+    private bindParameters;
+}

package/dist/tables/personalInformation/PersonalDataTable.js

@@ -0,0 +1,40 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class PersonalDataTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.personalData.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async insert(personalData) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.personalData.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, personalData);
+        await query.execute();
+        personalData.setId(id);
+    }
+    async update(personalData) {
+        const id = personalData.getId();
+        const query = this.createQuery(SQL.personalData.update);
+        query.bindParameter('id', id);
+        this.bindParameters(query, personalData);
+        await query.execute();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.personalData.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async delete(id) {
+        const query = this.createQuery(SQL.personalData.delete);
+        query.bindParameter('id', id);
+        await query.execute();
+    }
+    bindParameters(query, personalData) {
+        query.bindParameter('email', personalData.getEmail());
+        query.bindParameter('first_name', personalData.getFirstName());
+        query.bindParameter('last_name', personalData.getLastName());
+        query.bindParameter('phone_number', personalData.getPhoneNumber());
+    }
+}

package/dist/tables/public/AdminAccountsTable.d.ts

@@ -0,0 +1,14 @@
+import { QueryOptions, Table } from "@dascompany/database";
+import AdminRow from "../../types/rows/AdminRow";
+import Admin from "../../stockObjects/Admin";
+export default class AdminAccountsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<AdminRow>;
+    selectAll(queryOptions?: QueryOptions): Promise<AdminRow[]>;
+    selectId(queryOptions: QueryOptions): Promise<string>;
+    count(queryOptions: QueryOptions): Promise<number>;
+    insert(admin: Admin): Promise<string>;
+    update(admin: Admin): Promise<boolean>;
+    delete(accountId: string): Promise<number>;
+    private bindParameters;
+    private selectNextId;
+}

package/dist/tables/public/AdminAccountsTable.js

@@ -0,0 +1,66 @@
+import { ParameterType, QueryOptions, Table } from "@dascompany/database";
+import * as SQL from '../../SQL.json';
+export default class AdminAccountsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.selectId, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async count(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.count, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async insert(admin) {
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([
+            { name: 'email', type: ParameterType.string, value: admin.getEmail() }
+        ]);
+        let accountId = await this.selectId(queryOptions);
+        if (accountId)
+            throw new Error(`Admin account with email: ${admin.getEmail()} already exist!`);
+        else
+            accountId = await this.selectNextId();
+        const query = this.createQuery(SQL.adminAccounts.insert);
+        query.bindParameter('id', accountId);
+        this.bindParameters(query, admin);
+        await query.execute();
+        admin.setId(accountId);
+        return accountId;
+    }
+    async update(admin) {
+        const query = this.createQuery(SQL.adminAccounts.update);
+        query.bindParameter('id', admin.getId());
+        this.bindParameters(query, admin);
+        await query.execute();
+        return true;
+    }
+    async delete(accountId) {
+        const query = this.createQuery(SQL.adminAccounts.delete);
+        query.bindParameter('id', accountId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    bindParameters(query, admin) {
+        query.bindParameter('email', admin.getEmail());
+        query.bindParameter('first_name', admin.getFirstName());
+        query.bindParameter('last_name', admin.getLastName());
+        query.bindParameter('activated', admin.getActivated());
+        query.bindParameter('deleted', admin.getDeleted());
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.adminAccounts.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/public/ProductsTable.d.ts

@@ -0,0 +1,15 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import Product from '../../stockObjects/Product';
+import ProductRow from '../../types/rows/ProductRow';
+export default class ProductsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<ProductRow>;
+    selectAll(queryOptions?: QueryOptions): Promise<ProductRow[]>;
+    selectId(queryOptions: QueryOptions): Promise<string>;
+    insert(productData: Product): Promise<string>;
+    update(product: Product): Promise<boolean>;
+    delete(productId: string): Promise<number>;
+    selectMaxPrice(queryOption: QueryOptions): Promise<number>;
+    count(queryOption: QueryOptions): Promise<number>;
+    private selectNextId;
+    private bindParameters;
+}

package/dist/tables/public/ProductsTable.js

@@ -0,0 +1,83 @@
+import { ParameterType, QueryOptions, Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class ProductsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.products.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.products.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.products.selectId, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async insert(productData) {
+        const sku = productData.getSku();
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([
+            { name: 'sku', type: ParameterType.string, value: sku }
+        ]);
+        let productId = await this.selectId(queryOptions);
+        if (productId)
+            throw new Error(`Product with SKU: ${sku} already exist!`);
+        else
+            productId = await this.selectNextId();
+        const query = this.createQuery(SQL.products.insert);
+        query.bindParameter('id', productId);
+        this.bindParameters(query, productData);
+        await query.execute();
+        productData.setId(productId);
+        return productId;
+    }
+    async update(product) {
+        const query = this.createQuery(SQL.products.update);
+        query.bindParameter('id', product.getId());
+        this.bindParameters(query, product);
+        await query.execute();
+        return true;
+    }
+    async delete(productId) {
+        const query = this.createQuery(SQL.products.delete);
+        query.bindParameter('id', productId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    async selectMaxPrice(queryOption) {
+        const query = this.createQuery(SQL.products.maxPrice, queryOption);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async count(queryOption) {
+        const query = this.createQuery(SQL.products.count, queryOption);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.products.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, product) {
+        query.bindParameter('sku', product.getSku());
+        query.bindParameter('url', product.getUrl());
+        query.bindParameter('article_number', product.getArticleNumber());
+        query.bindParameter('title', product.getTitle());
+        query.bindParameter('subtitle', product.getSubtitle());
+        query.bindParameter('description', product.getDescription());
+        query.bindParameter('net_price', product.getNetPrice());
+        query.bindParameter('promotional_net_price', product.getPromotionalNetPrice());
+        query.bindParameter('vat', product.getVat());
+        query.bindParameter('color', product.getColor());
+        query.bindParameter('quantity', product.getQuantity());
+        query.bindParameter('width', product.getWidth());
+        query.bindParameter('length', product.getLength());
+        query.bindParameter('height', product.getHeight());
+        query.bindParameter('file_id', product.getFileId());
+        query.bindParameter('json_data', product.getJsonData());
+    }
+}

package/dist/tables/settings/CompanyDataTable.d.ts

@@ -0,0 +1,10 @@
+import { Table } from '@dascompany/database';
+import CompanyData from '../../stockObjects/CompanyData';
+import CompanyDataRow from '../../types/rows/CompanyDataRow';
+export default class CompanyDataTable extends Table {
+    select(): Promise<CompanyDataRow>;
+    update(companyData: CompanyData): Promise<boolean>;
+    insert(companyData: CompanyData): Promise<boolean>;
+    private selectNextId;
+    private bindParameters;
+}

package/dist/tables/settings/CompanyDataTable.js

@@ -0,0 +1,42 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class CompanyDataTable extends Table {
+    async select() {
+        const query = this.createQuery(SQL.companyData.select);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async update(companyData) {
+        const query = this.createQuery(SQL.companyData.update);
+        query.bindParameter('id', companyData.getId());
+        this.bindParameters(query, companyData);
+        await query.execute();
+        return true;
+    }
+    async insert(companyData) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.companyData.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, companyData);
+        await query.execute();
+        companyData.setId(id);
+        return true;
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.companyData.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, companyData) {
+        query.bindParameter('name', companyData.getName());
+        query.bindParameter('email', companyData.getEmail());
+        query.bindParameter('phone_number', companyData.getPhoneNumber());
+        query.bindParameter('registration_number', companyData.getRegistrationNumber());
+        query.bindParameter('tax_number', companyData.getTaxNumber());
+        query.bindParameter('swift_number', companyData.getSwiftNumber());
+        query.bindParameter('regon_number', companyData.getRegonNumber());
+        query.bindParameter('bank_account_number', companyData.getBankAccountNumber());
+        query.bindParameter('bank_name', companyData.getBankAccountName());
+        query.bindParameter('address_id', companyData.getAddressId());
+    }
+}

package/dist/tables/settings/DeliveryMethodsTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import DeliveryMethodI from '../../types/DeliveryMethodI';
+import DeliveryMethods from '../../stockObjects/DeliveryMethods';
+export default class DeliveryMethodsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<DeliveryMethodI>;
+    selectAll(queryOptions?: QueryOptions): Promise<DeliveryMethodI[]>;
+    insert(deliveryMethods: DeliveryMethods): Promise<boolean>;
+    update(deliveryMethods: DeliveryMethods): Promise<boolean>;
+    private selectNextId;
+    private bindParameters;
+}

package/dist/tables/settings/DeliveryMethodsTable.js

@@ -0,0 +1,39 @@
+import { Table } from '@dascompany/database';
+import * as SQL from '../../SQL.json';
+export default class DeliveryMethodsTable extends Table {
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.deliveryMethods.select, queryOptions);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.deliveryMethods.select, queryOptions);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(deliveryMethods) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.deliveryMethods.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, deliveryMethods);
+        await query.execute();
+        deliveryMethods.setId(id);
+        return true;
+    }
+    async update(deliveryMethods) {
+        const query = this.createQuery(SQL.deliveryMethods.update);
+        query.bindParameter('id', deliveryMethods.getId());
+        this.bindParameters(query, deliveryMethods);
+        await query.execute();
+        return true;
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.deliveryMethods.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, deliveryMethods) {
+        query.bindParameter('key', deliveryMethods.getKey());
+        query.bindParameter('active', deliveryMethods.getActive());
+    }
+}

package/dist/tables/settings/MarketPlacesTable.d.ts

@@ -0,0 +1,5 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import MarketPlaceRow from '../../types/rows/MarketPlaceRow';
+export default class MarketPlacesTable extends Table {
+    select(queryOptions: QueryOptions): Promise<MarketPlaceRow[]>;
+}

package/dist/tables/settings/MarketPlacesTable.js

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

package/dist/tables/settings/PaymentMethodsTable.d.ts

@@ -0,0 +1,11 @@
+import { QueryOptions, Table } from '@dascompany/database';
+import PaymentMethodI from '../../types/PaymentMethodI';
+import PaymentMethods from '../../stockObjects/PaymentMethods';
+export default class PaymentMethodsTable extends Table {
+    select(queryOptions: QueryOptions): Promise<PaymentMethodI>;
+    selectAll(queryOptions?: QueryOptions): Promise<PaymentMethodI[]>;
+    insert(paymentMethods: PaymentMethods): Promise<boolean>;
+    update(paymentMethods: PaymentMethods): Promise<boolean>;
+    private selectNextId;
+    private bindParameters;
+}