@dascompany/product 1.1.6 → 2.0.0

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

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

package/dist/tables/orders/PaymentDetailsTable.js

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

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

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

package/dist/tables/orders/PaymentStatusTypesTable.js

@@ -1,9 +1,8 @@
 import * as SQL from '../../SQL.json';
 import { Table } from '@dascompany/database';
 export default class PaymentStatusTypesTable extends Table {
-    async select(paymentStatusTypeId) {
-        const query = this.createQuery(SQL.paymentStatusTypes.select);
-        query.bindParameter('id', paymentStatusTypeId);
+    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

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

package/dist/tables/orders/PaymentStatusesTable.js

@@ -1,15 +1,13 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class PaymentStatusesTable extends Table {
-    async select(paymentDetailsId) {
-        const query = this.createQuery(SQL.paymentStatuses.select);
-        query.bindParameter('payment_details_id', paymentDetailsId);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.paymentStatuses.select, queryOptions);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectAll(paymentDetailsId) {
-        const query = this.createQuery(SQL.paymentStatuses.selectAll);
-        query.bindParameter('payment_details_id', paymentDetailsId);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.paymentStatuses.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }

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

@@ -1,9 +1,9 @@
-import { Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import Status from '../../stockObjects/Status';
 import StatusRow from '../../types/rows/StatusRow';
 export default class StatusesTable extends Table {
-    select(orderId: number): Promise<StatusRow>;
-    selectAll(orderId: number): Promise<StatusRow[]>;
+    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

@@ -1,15 +1,13 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class StatusesTable extends Table {
-    async select(orderId) {
-        const query = this.createQuery(SQL.statuses.select);
-        query.bindParameter('order_id', orderId);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.statuses.select, queryOptions);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectAll(orderId) {
-        const query = this.createQuery(SQL.statuses.selectAll);
-        query.bindParameter('order_id', orderId);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.statuses.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }

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

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

package/dist/tables/personalInformation/AddressesTable.js

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

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

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

package/dist/tables/personalInformation/CompanyDetailsTable.js

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

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

@@ -1,8 +1,8 @@
-import { Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import ContactDetails from '../../stockObjects/ContactDetails';
 import ContactDetailsRow from '../../types/rows/ContactDetailsRow';
 export default class ContactDetailsTable extends Table {
-    select(contactDetailsId: number): Promise<ContactDetailsRow>;
+    select(queryOptions: QueryOptions): Promise<ContactDetailsRow>;
     insert(contactDetails: ContactDetails): Promise<void>;
     update(contactDetails: ContactDetails): Promise<void>;
     selectNextId(): Promise<number>;

package/dist/tables/personalInformation/ContactDetailsTable.js

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

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

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

package/dist/tables/personalInformation/DeliveryDetailsTable.js

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

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

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

package/dist/tables/personalInformation/DeliveryStatusTypesTable.js

@@ -1,9 +1,8 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class DeliveryStatusTypesTable extends Table {
-    async select(deliveryStatusTypeId) {
-        const query = this.createQuery(SQL.deliveryStatusTypes.select);
-        query.bindParameter('id', deliveryStatusTypeId);
+    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

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

package/dist/tables/personalInformation/DeliveryStatusesTable.js

@@ -1,15 +1,13 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class DeliveryStatusesTable extends Table {
-    async select(deliveryDetailsId) {
-        const query = this.createQuery(SQL.deliveryStatuses.select);
-        query.bindParameter('delivery_details_id', deliveryDetailsId);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.deliveryStatuses.select, queryOptions);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectAll(deliveryDetailsId) {
-        const query = this.createQuery(SQL.deliveryStatuses.selectAll);
-        query.bindParameter('delivery_details_id', deliveryDetailsId);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.deliveryStatuses.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }

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

@@ -1,8 +1,8 @@
-import { Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import InvoiceDetails from '../../stockObjects/InvoiceDetails';
 import InvoiceDetailsRow from '../../types/rows/InvoiceDetailsRow';
 export default class InvoiceDetailsTable extends Table {
-    select(InvoiceDetailsId: number): Promise<InvoiceDetailsRow>;
+    select(queryOptions: QueryOptions): Promise<InvoiceDetailsRow>;
     insert(invoiceDetails: InvoiceDetails): Promise<void>;
     update(invoiceDetails: InvoiceDetails): Promise<void>;
     private selectNextId;

package/dist/tables/personalInformation/InvoiceDetailsTable.js

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

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

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

package/dist/tables/personalInformation/PersonalDataTable.js

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

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

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

package/dist/tables/public/AdminAccountsTable.js

@@ -1,20 +1,18 @@
-import { Table } from "@dascompany/database";
+import { ParameterType, QueryOptions, Table } from "@dascompany/database";
 import * as SQL from '../../SQL.json';
 export default class AdminAccountsTable extends Table {
-    async select(accountId) {
-        const query = this.createQuery(SQL.adminAccounts.select);
-        query.bindParameter('id', accountId);
+    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.selectAll, queryOptions);
+        const query = this.createQuery(SQL.adminAccounts.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }
-    async selectForEmail(email) {
-        const query = this.createQuery(SQL.adminAccounts.selectForEmail);
-        query.bindParameter('email', String(email).toUpperCase());
+    async selectId(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.selectId, queryOptions);
         const result = await query.execute();
         return result.getValue();
     }
@@ -24,7 +22,11 @@ export default class AdminAccountsTable extends Table {
         return result.getValue();
     }
     async insert(admin) {
-        let accountId = await this.selectForEmail(admin.getEmail());
+        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

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

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

package/dist/tables/public/ProductsTable.js

@@ -1,43 +1,28 @@
-import { Table } from '@dascompany/database';
+import { ParameterType, QueryOptions, Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class ProductsTable extends Table {
-    async select(productId) {
-        const query = this.createQuery(SQL.products.select);
-        query.bindParameter('id', productId);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.products.select, queryOptions);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectAll(queryOption) {
-        const query = this.createQuery(SQL.products.selectAll, queryOption);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.products.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }
-    async selectAllActive(queryOption) {
-        const query = this.createQuery(SQL.products.selectAllActive, queryOption);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async selectForSku(sku) {
-        const query = this.createQuery(SQL.products.selectForSku);
-        query.bindParameter('sku', String(sku).toUpperCase());
-        const result = await query.execute();
-        return result.getRow();
-    }
-    async selectForUrl(url) {
-        const query = this.createQuery(SQL.products.selectForUrl);
-        query.bindParameter('url', url.toUpperCase());
-        const result = await query.execute();
-        return result.getRow();
-    }
-    async selectIdForSku(sku) {
-        const query = this.createQuery(SQL.products.selectIdForSku);
-        query.bindParameter('sku', String(sku).toUpperCase());
+    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();
-        let productId = await this.selectIdForSku(sku);
+        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
@@ -45,8 +30,8 @@ export default class ProductsTable extends Table {
         const query = this.createQuery(SQL.products.insert);
         query.bindParameter('id', productId);
         this.bindParameters(query, productData);
-        productData.setId(productId);
         await query.execute();
+        productData.setId(productId);
         return productId;
     }
     async update(product) {
@@ -62,29 +47,34 @@ export default class ProductsTable extends Table {
         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();
     }
-    bindParameters(query, productData) {
-        query.bindParameter('sku', productData.getSku());
-        query.bindParameter('url', productData.getUrl());
-        query.bindParameter('title', productData.getTitle());
-        query.bindParameter('description', productData.getDescription());
-        query.bindParameter('net_price', productData.getNetPrice());
-        query.bindParameter('vat', productData.getVat());
-        query.bindParameter('color', productData.getColor());
-        query.bindParameter('quantity', productData.getQuantity());
-        query.bindParameter('width', productData.getWidth());
-        query.bindParameter('length', productData.getLength());
-        query.bindParameter('height', productData.getHeight());
-        query.bindParameter('file_id', productData.getFileId());
-        query.bindParameter('json_data', productData.getJsonData());
-    }
     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('title', product.getTitle());
+        query.bindParameter('description', product.getDescription());
+        query.bindParameter('net_price', product.getNetPrice());
+        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/DeliveryMethodsTable.d.ts

@@ -1,12 +1,11 @@
-import { Table } from '@dascompany/database';
+import { QueryOptions, Table } from '@dascompany/database';
 import DeliveryMethodI from '../../types/DeliveryMethodI';
-import DeliveryMethodRow from '../../types/rows/DeliveryMethodRow';
 import DeliveryMethods from '../../stockObjects/DeliveryMethods';
 export default class DeliveryMethodsTable extends Table {
-    select(id: number): Promise<DeliveryMethodI>;
-    selectAll(): Promise<DeliveryMethodI[]>;
-    selectAllActive(): Promise<DeliveryMethodRow[]>;
+    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

@@ -1,19 +1,13 @@
 import { Table } from '@dascompany/database';
 import * as SQL from '../../SQL.json';
 export default class DeliveryMethodsTable extends Table {
-    async select(id) {
-        const query = this.createQuery(SQL.deliveryMethods.select);
-        query.bindParameter('id', id);
+    async select(queryOptions) {
+        const query = this.createQuery(SQL.deliveryMethods.select, queryOptions);
         const result = await query.execute();
         return result.getRow();
     }
-    async selectAll() {
-        const query = this.createQuery(SQL.deliveryMethods.selectAll);
-        const result = await query.execute();
-        return result.getRows();
-    }
-    async selectAllActive() {
-        const query = this.createQuery(SQL.deliveryMethods.selectAllActive);
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.deliveryMethods.select, queryOptions);
         const result = await query.execute();
         return result.getRows();
     }
@@ -21,8 +15,7 @@ export default class DeliveryMethodsTable extends Table {
         const id = await this.selectNextId();
         const query = this.createQuery(SQL.deliveryMethods.insert);
         query.bindParameter('id', id);
-        query.bindParameter('key', deliveryMethods.getKey());
-        query.bindParameter('active', deliveryMethods.getActive());
+        this.bindParameters(query, deliveryMethods);
         await query.execute();
         deliveryMethods.setId(id);
         return true;
@@ -30,8 +23,7 @@ export default class DeliveryMethodsTable extends Table {
     async update(deliveryMethods) {
         const query = this.createQuery(SQL.deliveryMethods.update);
         query.bindParameter('id', deliveryMethods.getId());
-        query.bindParameter('key', deliveryMethods.getKey());
-        query.bindParameter('active', deliveryMethods.getActive());
+        this.bindParameters(query, deliveryMethods);
         await query.execute();
         return true;
     }
@@ -40,4 +32,8 @@ export default class DeliveryMethodsTable extends Table {
         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/PaymentMethodsTable.d.ts

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