@dascompany/product 4.3.0 → 4.4.1

package/dist/reader/AdminReader.js

@@ -1,37 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-export default class AdminReader {
-    static async get(queryOptions) {
-        const account = await DatabaseConnection.getInstance().adminAccounts.select(queryOptions);
-        return this.correctAdmin(account);
-    }
-    static async getId(queryOptions) {
-        return await DatabaseConnection.getInstance().adminAccounts.selectId(queryOptions);
-    }
-    static async getAll(queryOptions) {
-        const adminAccounts = await DatabaseConnection.getInstance().adminAccounts.selectAll(queryOptions);
-        return this.correctAdmins(adminAccounts);
-    }
-    static async getQuantity(queryOptions) {
-        const quantity = await DatabaseConnection.getInstance().adminAccounts.count(queryOptions);
-        return Number(quantity);
-    }
-    static correctAdmins(admins) {
-        const correctAdmins = [];
-        for (let i = 0; i < admins.length; i++) {
-            const correctAdmin = this.correctAdmin(admins[i]);
-            correctAdmins.push(correctAdmin);
-        }
-        return correctAdmins;
-    }
-    static correctAdmin(admin) {
-        return {
-            id: admin.id,
-            email: admin.email,
-            firstName: admin.first_name,
-            lastName: admin.last_name,
-            activated: admin.activated,
-            deleted: admin.deleted,
-            createdAt: admin.created_at
-        };
-    }
-}

package/dist/reader/ClientAccountReader.d.ts

@@ -1,10 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import ClientAccountI from "../types/ClientAccountI";
-export default class ClientAccountReader {
-    static get(queryOptions: QueryOptions): Promise<ClientAccountI>;
-    static getAll(queryOptions?: QueryOptions): Promise<ClientAccountI[]>;
-    static getQuantity(queryOptions: QueryOptions): Promise<number>;
-    static getId(queryOptions: QueryOptions): Promise<string | null>;
-    private static correctClientsFromRows;
-    private static correctData;
-}

package/dist/reader/ClientAccountReader.js

@@ -1,39 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-export default class ClientAccountReader {
-    static async get(queryOptions) {
-        const account = await DatabaseConnection.getInstance().clientAccounts.select(queryOptions);
-        return this.correctData(account);
-    }
-    static async getAll(queryOptions) {
-        const clientAccounts = await DatabaseConnection.getInstance().clientAccounts.selectAll(queryOptions);
-        return this.correctClientsFromRows(clientAccounts);
-    }
-    static async getQuantity(queryOptions) {
-        const quantity = await DatabaseConnection.getInstance().clientAccounts.count(queryOptions);
-        return Number(quantity);
-    }
-    static async getId(queryOptions) {
-        const accountId = await DatabaseConnection.getInstance().clientAccounts.selectId(queryOptions);
-        return accountId;
-    }
-    static correctClientsFromRows(dataRows) {
-        const clients = [];
-        for (const dataRow of dataRows) {
-            const client = this.correctData(dataRow);
-            clients.push(client);
-        }
-        return clients;
-    }
-    static correctData(client) {
-        return {
-            id: client.id,
-            email: client.email,
-            createdAt: client.created_at,
-            activated: client.activated,
-            deleted: client.deleted,
-            personalDataId: client.personal_data_id,
-            deliveryDetailsId: client.delivery_details_id,
-            companyDetailsId: client.company_details_id,
-        };
-    }
-}

package/dist/reader/CompanyDataReader.d.ts

@@ -1,4 +0,0 @@
-import CompanyDataI from "../types/CompanyDataI";
-export default class CompanyDataReader {
-    static get(): Promise<CompanyDataI>;
-}

package/dist/reader/CompanyDataReader.js

@@ -1,39 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import AddressesReader from "./AddressesReader";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class CompanyDataReader {
-    static async get() {
-        const companyData = await DatabaseConnection.getInstance().companyData.select();
-        if (companyData) {
-            const address = companyData?.address_id ? await AddressesReader.get(createQueryOptionsForId(companyData.address_id)) : null;
-            return {
-                id: companyData.id,
-                name: companyData.name,
-                email: companyData.email,
-                phoneNumber: companyData.phone_number,
-                registartionNumber: companyData.registration_number,
-                taxNumber: companyData.tax_number,
-                swiftNumber: companyData.swift_number,
-                regonNumber: companyData.regon_number,
-                bankAccountNumber: companyData.bank_account_number,
-                bankName: companyData.bank_name,
-                address: address
-            };
-        }
-        else {
-            return {
-                id: '',
-                name: '',
-                email: '',
-                phoneNumber: '',
-                registartionNumber: '',
-                taxNumber: '',
-                swiftNumber: '',
-                regonNumber: '',
-                bankAccountNumber: '',
-                bankName: '',
-                address: null
-            };
-        }
-    }
-}

package/dist/reader/CompanyDetailsReader.d.ts

@@ -1,5 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import CompanyDetailsI from "../types/CompanyDetailsI";
-export default class CompanyDetailsReader {
-    static get(queryOptions: QueryOptions): Promise<CompanyDetailsI>;
-}

package/dist/reader/CompanyDetailsReader.js

@@ -1,18 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import AddressesReader from "./AddressesReader";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class CompanyDetailsReader {
-    static async get(queryOptions) {
-        const companyDetails = await DatabaseConnection.getInstance().companyDetails.select(queryOptions);
-        const address = await AddressesReader.get(createQueryOptionsForId(companyDetails.address_id));
-        if (companyDetails)
-            return {
-                id: companyDetails.id,
-                name: companyDetails.name,
-                taxNumber: companyDetails.tax_number,
-                address
-            };
-        else
-            throw Error(`no companyDetails found with queryOptions: ${queryOptions}`);
-    }
-}

package/dist/reader/DeliveryDetailsReader.d.ts

@@ -1,5 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import DeliveryDetailsI from "../types/DeliveryDetailsI";
-export default class DeliveryDetailsReader {
-    static get(queryOptions: QueryOptions): Promise<DeliveryDetailsI>;
-}

package/dist/reader/DeliveryDetailsReader.js

@@ -1,26 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import AddressesReader from "./AddressesReader";
-import DeliveryMethodReader from "./DeliveryMethodReader";
-import PersonalDataReader from "./PersonalDataReader";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class DeliveryDetailsReader {
-    static async get(queryOptions) {
-        const deliveryDetails = await DatabaseConnection.getInstance().deliveryDetails.select(queryOptions);
-        const id = deliveryDetails.id;
-        let personalData = null;
-        let address = null;
-        let deliveryMethod = null;
-        if (deliveryDetails.personal_data_id)
-            personalData = await PersonalDataReader.get(createQueryOptionsForId(deliveryDetails.personal_data_id));
-        if (deliveryDetails.address_id)
-            address = await AddressesReader.get(createQueryOptionsForId(deliveryDetails.address_id));
-        if (deliveryDetails.delivery_method_id)
-            deliveryMethod = await DeliveryMethodReader.get(createQueryOptionsForId(deliveryDetails.delivery_method_id));
-        return {
-            id,
-            personalData,
-            address,
-            deliveryMethod
-        };
-    }
-}

package/dist/reader/DeliveryMethodReader.d.ts

@@ -1,6 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import DeliveryMethodI from "../types/DeliveryMethodI";
-export default class DeliveryMethodReader {
-    static get(queryOptions: QueryOptions): Promise<DeliveryMethodI>;
-    static getAll(queryOptions?: QueryOptions): Promise<DeliveryMethodI[]>;
-}

package/dist/reader/DeliveryMethodReader.js

@@ -1,11 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-export default class DeliveryMethodReader {
-    static async get(queryOptions) {
-        const deliveryMethod = await DatabaseConnection.getInstance().deliveryMethods.select(queryOptions);
-        return deliveryMethod;
-    }
-    static async getAll(queryOptions) {
-        const deliveryMethods = await DatabaseConnection.getInstance().deliveryMethods.selectAll(queryOptions);
-        return deliveryMethods;
-    }
-}

package/dist/reader/DeliveryStatusReader.d.ts

@@ -1,6 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-export default class DeliveryStatusReader {
-    static get(queryOptions: QueryOptions): Promise<any>;
-    static getAll(queryOptions?: QueryOptions): Promise<any[]>;
-    private static correctDeliveryStatus;
-}

package/dist/reader/DeliveryStatusReader.js

@@ -1,29 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class DeliveryStatusReader {
-    static async get(queryOptions) {
-        const deliveryStatus = await DatabaseConnection.getInstance().deliveryStatuses.select(queryOptions);
-        if (deliveryStatus)
-            return await this.correctDeliveryStatus(deliveryStatus);
-        else
-            return {};
-    }
-    static async getAll(queryOptions) {
-        const deliveryStatusesData = await DatabaseConnection.getInstance().deliveryStatuses.selectAll(queryOptions);
-        const deliveryStatuses = [];
-        for (let i = 0; i < deliveryStatusesData.length; i++) {
-            const deliveryStatus = await this.correctDeliveryStatus(deliveryStatusesData[i]);
-            deliveryStatuses.push(deliveryStatus);
-        }
-        return deliveryStatuses;
-    }
-    static async correctDeliveryStatus(deliveryStatus) {
-        const deliveryStatusType = await DatabaseConnection.getInstance().deliveryStatusTypes.select(createQueryOptionsForId(deliveryStatus.delivery_status_type_id));
-        return {
-            id: deliveryStatus.id,
-            type: deliveryStatusType,
-            userId: deliveryStatus.user_id,
-            createdAt: deliveryStatus.created_at
-        };
-    }
-}

package/dist/reader/FileConnectionsReader.d.ts

@@ -1,7 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import FileConnectionI from "../types/FileConnectionI";
-export default class FileConnectionsReader {
-    static getAll(queryOptions?: QueryOptions): Promise<FileConnectionI[]>;
-    private static correctFileConnections;
-    private static correctFileConnection;
-}

package/dist/reader/FileConnectionsReader.js

@@ -1,24 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-export default class FileConnectionsReader {
-    static async getAll(queryOptions) {
-        const fileConnections = await DatabaseConnection.getInstance().fileConnections.selectAll(queryOptions);
-        return this.correctFileConnections(fileConnections);
-    }
-    static correctFileConnections(fileConnectionsRows) {
-        const fileConnections = [];
-        for (let i = 0; i < fileConnectionsRows.length; i++) {
-            const fileConnection = this.correctFileConnection(fileConnectionsRows[i]);
-            fileConnections.push(fileConnection);
-        }
-        return fileConnections;
-    }
-    static correctFileConnection(fileConnections) {
-        const correctFileConnection = {
-            fileId: fileConnections.file_id,
-            connectionType: fileConnections.connection_type,
-            connectionId: fileConnections.connection_id,
-            sequence: Number(fileConnections.sequence)
-        };
-        return correctFileConnection;
-    }
-}

package/dist/reader/FilesReader.d.ts

@@ -1,11 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import FileI from "../types/FileI";
-export default class FilesReader {
-    static get(queryOptions: QueryOptions): Promise<FileI>;
-    static getAll(queryOptions?: QueryOptions): Promise<FileI[]>;
-    static getId(queryOptions: QueryOptions): Promise<string>;
-    static getQuantity(queryOptions: any): Promise<number>;
-    static getForConnection(queryOptions: QueryOptions): Promise<FileI[]>;
-    private static correctFiles;
-    private static correctFile;
-}

package/dist/reader/FilesReader.js

@@ -1,43 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-export default class FilesReader {
-    static async get(queryOptions) {
-        const file = await DatabaseConnection.getInstance().files.select(queryOptions);
-        return this.correctFile(file);
-    }
-    static async getAll(queryOptions) {
-        const file = await DatabaseConnection.getInstance().files.selectAll(queryOptions);
-        return this.correctFiles(file);
-    }
-    static async getId(queryOptions) {
-        const fileId = await DatabaseConnection.getInstance().files.selectId(queryOptions);
-        return fileId;
-    }
-    static async getQuantity(queryOptions) {
-        const quantity = await DatabaseConnection.getInstance().files.count(queryOptions);
-        return Number(quantity);
-    }
-    static async getForConnection(queryOptions) {
-        const files = await DatabaseConnection.getInstance().files.selectForConnection(queryOptions);
-        return this.correctFiles(files);
-    }
-    static correctFiles(fileRows) {
-        const fileConnections = [];
-        for (let i = 0; i < fileRows.length; i++) {
-            const fileConnection = this.correctFile(fileRows[i]);
-            fileConnections.push(fileConnection);
-        }
-        return fileConnections;
-    }
-    static correctFile(file) {
-        const correctFile = {
-            id: file.id,
-            name: file.name,
-            catalog: file.catalog,
-            type: Number(file.type),
-            createdAt: file.created_at,
-            alt: file.alt,
-            title: file.title
-        };
-        return correctFile;
-    }
-}

package/dist/reader/MarketPlacesReader.d.ts

@@ -1,8 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import MarketPlaceI from "../types/MarketPlaceI";
-export default class MarketPlacesReader {
-    static get(queryOptions: QueryOptions): Promise<MarketPlaceI>;
-    static getAll(queryOptions: QueryOptions): Promise<MarketPlaceI[]>;
-    private static correctMarkets;
-    private static correctMarket;
-}

package/dist/reader/MarketPlacesReader.js

@@ -1,28 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-export default class MarketPlacesReader {
-    static async get(queryOptions) {
-        if (!queryOptions.getLimit())
-            queryOptions.setLimit(1, 0);
-        const marketPlace = await DatabaseConnection.getInstance().marketPlaces.select(queryOptions);
-        return this.correctMarket(marketPlace[0]);
-    }
-    static async getAll(queryOptions) {
-        const marketPlace = await DatabaseConnection.getInstance().marketPlaces.select(queryOptions);
-        return this.correctMarkets(marketPlace);
-    }
-    static correctMarkets(marketRows) {
-        const markets = [];
-        marketRows.forEach((market) => {
-            markets.push(this.correctMarket(market));
-        });
-        return markets;
-    }
-    static correctMarket(marketRow) {
-        const correctMarket = {
-            id: marketRow.id,
-            country: marketRow.country,
-            vatRate: Number(marketRow.vat_rate)
-        };
-        return correctMarket;
-    }
-}

package/dist/reader/OrderProductsReader.d.ts

@@ -1,7 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import OrderProductI from "../types/OrderProductI";
-export default class OrderProductsReader {
-    static getAll(queryOptions?: QueryOptions): Promise<OrderProductI[]>;
-    private static correctOrderProducts;
-    private static correctProduct;
-}

package/dist/reader/OrderProductsReader.js

@@ -1,40 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import FilesReader from "./FilesReader";
-import PriceConverter from "../utils/PriceConverter";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class OrderProductsReader {
-    static async getAll(queryOptions) {
-        const orderProducts = await DatabaseConnection.getInstance().ordersProducts.selectAll(queryOptions);
-        const correctProducts = await this.correctOrderProducts(orderProducts);
-        return correctProducts;
-    }
-    static async correctOrderProducts(products) {
-        const correctProducts = [];
-        for (let i = 0; i < products.length; i++) {
-            const correctProduct = await this.correctProduct(products[i]);
-            correctProducts.push(correctProduct);
-        }
-        return correctProducts;
-    }
-    static async correctProduct(orderProduct) {
-        const thumbnail = await FilesReader.get(createQueryOptionsForId(orderProduct.file_id));
-        const correctProduct = {
-            id: orderProduct.id,
-            productId: orderProduct.product_id,
-            sku: orderProduct.sku,
-            title: orderProduct.title,
-            price: {
-                netPrice: orderProduct.net_price,
-                grossPrice: PriceConverter.netToGrossPrice(Number(orderProduct.net_price), Number(orderProduct.vat))
-            },
-            installation: orderProduct.installation_price ? true : false,
-            installationPrice: {
-                netPrice: orderProduct.installation_price,
-                grossPrice: PriceConverter.netToGrossPrice(Number(orderProduct.installation_price), Number(orderProduct.vat))
-            },
-            vat: orderProduct.vat,
-            thumbnail,
-        };
-        return correctProduct;
-    }
-}

package/dist/reader/OrderReader.d.ts

@@ -1,10 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import OrderI from "../types/OrderI";
-export default class OrderReader {
-    static get(queryOptions: QueryOptions): Promise<OrderI>;
-    static getAll(queryOptions?: QueryOptions): Promise<OrderI[]>;
-    static getAllForClient(queryOptions: QueryOptions): Promise<OrderI[]>;
-    static getQuantity(queryOptions: QueryOptions): Promise<number>;
-    private static correctOrders;
-    private static correctOrder;
-}

package/dist/reader/OrderReader.js

@@ -1,57 +0,0 @@
-import { ParameterType, QueryOptions } from "@dascompany/database";
-import DatabaseConnection from "../DatabaseConnection";
-import OrderStatusReader from "./OrderStatusReader";
-import PriceConverter from "../utils/PriceConverter";
-export default class OrderReader {
-    static async get(queryOptions) {
-        const orderData = await DatabaseConnection.getInstance().orders.select(queryOptions);
-        return this.correctOrder(orderData);
-    }
-    static async getAll(queryOptions) {
-        const orders = await DatabaseConnection.getInstance().orders.selectAll(queryOptions);
-        const correctOrders = [];
-        for (let i = 0; i < orders.length; i++) {
-            const correctOrder = await this.correctOrder(orders[i]);
-            correctOrders.push(correctOrder);
-        }
-        return correctOrders;
-    }
-    static async getAllForClient(queryOptions) {
-        const orderRows = await DatabaseConnection.getInstance().orders.selectAll(queryOptions);
-        const orders = await this.correctOrders(orderRows);
-        return orders;
-    }
-    static async getQuantity(queryOptions) {
-        const quantity = await DatabaseConnection.getInstance().orders.count(queryOptions);
-        return Number(quantity);
-    }
-    static async correctOrders(orderRows) {
-        const orders = [];
-        for (let i = 0; i < orderRows.length; i++) {
-            const order = await this.correctOrder(orderRows[i]);
-            orders.push(order);
-        }
-        return orders;
-    }
-    static async correctOrder(order) {
-        const queryOptions = new QueryOptions();
-        queryOptions.setWhere([{ name: 'order_id', type: ParameterType.bigint, value: order.id }]);
-        queryOptions.setOrderBy([{ key: 'created_at', order: 'DESC' }]);
-        const status = await OrderStatusReader.getNewest(queryOptions);
-        const correctOrder = {
-            id: order.id,
-            email: order.email,
-            price: { netPrice: order.net_price, grossPrice: PriceConverter.netToGrossPrice(order.net_price, order.vat) },
-            vat: order.vat,
-            createdAt: order.created_at,
-            clientId: order.client_id,
-            deliveryDetailsId: order.delivery_details_id,
-            companyDetailsId: order.company_details_id,
-            paymentDetailsId: order.payment_details_id,
-            zsiId: order.zsi_id,
-            invoice: order.invoice,
-            status
-        };
-        return correctOrder;
-    }
-}

package/dist/reader/OrderStatusReader.d.ts

@@ -1,6 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-export default class OrderStatusReader {
-    static getNewest(queryOptions: QueryOptions): Promise<any>;
-    static getAll(queryOptions?: QueryOptions): Promise<any[]>;
-    private static correctStatus;
-}

package/dist/reader/OrderStatusReader.js

@@ -1,29 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import StatusTypesReader from "./StatusTypesReader";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class OrderStatusReader {
-    static async getNewest(queryOptions) {
-        const statusRow = await DatabaseConnection.getInstance().statuses.selectAll(queryOptions);
-        return this.correctStatus(statusRow[0]);
-    }
-    static async getAll(queryOptions) {
-        const statuses = await DatabaseConnection.getInstance().statuses.selectAll(queryOptions);
-        const correctStatuss = [];
-        for (let i = 0; i < statuses.length; i++) {
-            const correctStatus = await this.correctStatus(statuses[i]);
-            correctStatuss.push(correctStatus);
-        }
-        return correctStatuss;
-    }
-    static async correctStatus(status) {
-        const statusName = await StatusTypesReader.get(createQueryOptionsForId(status.type));
-        const correctStatus = {
-            id: status.id,
-            orderId: status.order_id,
-            createdAt: status.created_at,
-            userId: status.user_id,
-            type: statusName
-        };
-        return correctStatus;
-    }
-}

package/dist/reader/PersonalDataReader.d.ts

@@ -1,6 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import PersonalDataI from "../types/PersonalDataI";
-export default class PersonalDataReader {
-    static get(queryOptions: QueryOptions): Promise<PersonalDataI>;
-    private static correctPersonalData;
-}

package/dist/reader/PersonalDataReader.js

@@ -1,19 +0,0 @@
-import DatabaseConnection from "../DatabaseConnection";
-import correctPhoneNumber from "../utils/correctPhoneNumber";
-export default class PersonalDataReader {
-    static async get(queryOptions) {
-        const personalDataRow = await DatabaseConnection.getInstance().personalData.select(queryOptions);
-        const personalData = this.correctPersonalData(personalDataRow);
-        return personalData;
-    }
-    static correctPersonalData(personalDataRow) {
-        const phoneNumber = correctPhoneNumber(personalDataRow.phone_number);
-        return {
-            id: personalDataRow.id,
-            firstName: personalDataRow.first_name,
-            lastName: personalDataRow.last_name,
-            email: personalDataRow.email,
-            phoneNumber
-        };
-    }
-}

package/dist/reader/ProductReader.d.ts

@@ -1,11 +0,0 @@
-import { QueryOptions } from "@dascompany/database";
-import ProductI from "../types/ProductI";
-export default class ProductReader {
-    static get(queryOption: QueryOptions, vat: number): Promise<ProductI>;
-    static getAll(queryOption: QueryOptions, vat: number): Promise<ProductI[]>;
-    static getId(queryOptions: QueryOptions): Promise<string>;
-    static getQuantity(queryOptions: QueryOptions): Promise<number>;
-    static getMaxPrice(queryOptions: QueryOptions, vat: number): Promise<number>;
-    private static correctProducts;
-    private static correctProduct;
-}

package/dist/reader/ProductReader.js

@@ -1,64 +0,0 @@
-import { ParameterType, QueryOptions } from "@dascompany/database";
-import FilesReader from "./FilesReader";
-import DatabaseConnection from "../DatabaseConnection";
-import FileConnectionTypeE from "../types/FileConnectionTypeE";
-import PriceConverter from "../utils/PriceConverter";
-import createQueryOptionsForId from "../utils/createQueryOptionsForId";
-export default class ProductReader {
-    static async get(queryOption, vat) {
-        const productRow = await DatabaseConnection.getInstance().products.select(queryOption);
-        const queryOptionsFiles = new QueryOptions();
-        queryOptionsFiles.setWhere([{ name: 'connection_id', type: ParameterType.bigint, value: productRow.id }, { name: 'connection_type', type: ParameterType.string, value: FileConnectionTypeE.product }]);
-        queryOptionsFiles.setOrderBy([{ key: 'sequence', order: 'asc' }]);
-        const files = await FilesReader.getForConnection(queryOptionsFiles);
-        const product = await this.correctProduct(productRow, vat);
-        return { ...product, files };
-    }
-    static async getAll(queryOption, vat) {
-        const products = await DatabaseConnection.getInstance().products.selectAll(queryOption);
-        return this.correctProducts(products, vat);
-    }
-    static async getId(queryOptions) {
-        return await DatabaseConnection.getInstance().products.selectId(queryOptions);
-    }
-    static async getQuantity(queryOptions) {
-        const quantity = await DatabaseConnection.getInstance().products.count(queryOptions);
-        return Number(quantity);
-    }
-    static async getMaxPrice(queryOptions, vat) {
-        const price = await DatabaseConnection.getInstance().products.selectMaxPrice(queryOptions);
-        const grossPrice = PriceConverter.netToGrossPrice(Number(price), vat);
-        return grossPrice;
-    }
-    static async correctProducts(products, vat) {
-        const correctProducts = [];
-        for (let i = 0; i < products.length; i++) {
-            const correctProduct = await this.correctProduct(products[i], vat);
-            correctProducts.push(correctProduct);
-        }
-        return correctProducts;
-    }
-    static async correctProduct(product, vat) {
-        const thumbnail = await FilesReader.get(createQueryOptionsForId(product.file_id));
-        return {
-            id: product.id,
-            sku: product.sku,
-            articleNumber: product.article_number,
-            url: product.url,
-            title: product.title,
-            subtitle: product.subtitle,
-            description: product.description,
-            price: { netPrice: product.net_price, grossPrice: PriceConverter.netToGrossPrice(Number(product.net_price), vat) },
-            promotionalPrice: { netPrice: product.promotional_net_price, grossPrice: PriceConverter.netToGrossPrice(product.promotional_net_price, vat) },
-            color: product.color,
-            quantity: product.quantity,
-            width: product.width,
-            height: product.height,
-            length: product.length,
-            createdAt: product.created_at,
-            deleted: product.deleted,
-            thumbnail: thumbnail ? thumbnail : null,
-            jsonData: product.json_data
-        };
-    }
-}