@dascompany/product 4.5.1 → 4.5.3

package/dist/mappers/DeliveryMethodsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class DeliveryMethodsMapper {
+    deliveryMethods;
+    deliveryMethodsTable;
+    constructor(deliveryMethods) {
+        this.deliveryMethodsTable = DatabaseConnection.getInstance().deliveryMethods;
+        this.deliveryMethods = deliveryMethods;
+    }
+    async save() {
+        if (this.deliveryMethods.getId())
+            await this.deliveryMethodsTable.update(this.deliveryMethods);
+        else
+            await this.deliveryMethodsTable.insert(this.deliveryMethods);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/DeliveryStatusMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import DeliveryStatus from "../stockObjects/DeliveryStatus";
+export default class DeliveryStatusMapper implements StockObjectMapper {
+    private deliveryStatus;
+    private deliveryStatusesTable;
+    constructor(deliveryStatus: DeliveryStatus);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/DeliveryStatusMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class DeliveryStatusMapper {
+    deliveryStatus;
+    deliveryStatusesTable;
+    constructor(deliveryStatus) {
+        this.deliveryStatusesTable = DatabaseConnection.getInstance().deliveryStatuses;
+        this.deliveryStatus = deliveryStatus;
+    }
+    async save() {
+        await this.deliveryStatusesTable.insert(this.deliveryStatus);
+    }
+    async delete() {
+        throw Error('Method not implemented');
+    }
+}

package/dist/mappers/FileConnectionMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from '@dascompany/database';
+import FileConnection from '../stockObjects/FileConnection';
+export default class FileConnectionMapper implements StockObjectMapper {
+    private fileConnection;
+    private fileConnectionsTable;
+    constructor(fileConnection: FileConnection);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/FileConnectionMapper.js

@@ -0,0 +1,18 @@
+import DatabaseConnection from '../DatabaseConnection';
+import createQueryOptionsForId from '../utils/createQueryOptionsForId';
+export default class FileConnectionMapper {
+    fileConnection;
+    fileConnectionsTable;
+    constructor(fileConnection) {
+        this.fileConnectionsTable = DatabaseConnection.getInstance().fileConnections;
+        this.fileConnection = fileConnection;
+    }
+    async save() {
+        const id = this.fileConnection.getId();
+        if (id)
+            await this.fileConnectionsTable.delete(createQueryOptionsForId(id));
+        await this.fileConnectionsTable.insert(this.fileConnection);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/FileMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import File from "../stockObjects/File";
+export default class FileMapper implements StockObjectMapper {
+    private file;
+    private filesTable;
+    constructor(file: File);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/FileMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class FileMapper {
+    file;
+    filesTable;
+    constructor(file) {
+        this.filesTable = DatabaseConnection.getInstance().files;
+        this.file = file;
+    }
+    async save() {
+        if (this.file.getId())
+            await this.filesTable.update(this.file);
+        else
+            await this.filesTable.insert(this.file);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/OrderMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import Order from "../stockObjects/Order";
+export default class OrderMapper implements StockObjectMapper {
+    private order;
+    private orderTable;
+    constructor(order: Order);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/OrderMapper.js

@@ -0,0 +1,19 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class OrderMapper {
+    order;
+    orderTable;
+    constructor(order) {
+        this.orderTable = DatabaseConnection.getInstance().orders;
+        this.order = order;
+    }
+    async save() {
+        const orderId = this.order.getId();
+        if (orderId)
+            await this.orderTable.update(this.order);
+        else
+            await this.orderTable.insert(this.order);
+    }
+    async delete() {
+        throw Error('method not implemented');
+    }
+}

package/dist/mappers/OrderProductMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import OrderProduct from "../stockObjects/OrderProduct";
+export default class OrderProductMapper implements StockObjectMapper {
+    private orderProduct;
+    private orderProductsTable;
+    constructor(orderProduct: OrderProduct);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/OrderProductMapper.js

@@ -0,0 +1,19 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class OrderProductMapper {
+    orderProduct;
+    orderProductsTable;
+    constructor(orderProduct) {
+        this.orderProductsTable = DatabaseConnection.getInstance().ordersProducts;
+        this.orderProduct = orderProduct;
+    }
+    async save() {
+        await this.orderProductsTable.insert(this.orderProduct);
+    }
+    async delete() {
+        const orderId = this.orderProduct.getId();
+        if (orderId)
+            await this.orderProductsTable.delete(orderId);
+        else
+            throw new Error('Can`t remove the order and product connection without providing its ID');
+    }
+}

package/dist/mappers/PaymentDetailsMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import PaymentDetails from "../stockObjects/PaymentDetails";
+export default class PaymentDetailsMapper implements StockObjectMapper {
+    private paymentDetails;
+    private paymentDetailsTable;
+    constructor(paymentDetails: PaymentDetails);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PaymentDetailsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PaymentDetailsMapper {
+    paymentDetails;
+    paymentDetailsTable;
+    constructor(paymentDetails) {
+        this.paymentDetailsTable = DatabaseConnection.getInstance().paymentDetails;
+        this.paymentDetails = paymentDetails;
+    }
+    async save() {
+        if (this.paymentDetails.getId())
+            await this.paymentDetailsTable.update(this.paymentDetails);
+        else
+            await this.paymentDetailsTable.insert(this.paymentDetails);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/PaymentMethodsMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import PaymentMethods from "../stockObjects/PaymentMethods";
+export default class PaymentMethodsMapper implements StockObjectMapper {
+    private paymentMethods;
+    private paymentMethodsTable;
+    constructor(paymentMethods: PaymentMethods);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PaymentMethodsMapper.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PaymentMethodsMapper {
+    paymentMethods;
+    paymentMethodsTable;
+    constructor(paymentMethods) {
+        this.paymentMethodsTable = DatabaseConnection.getInstance().paymentMethods;
+        this.paymentMethods = paymentMethods;
+    }
+    async save() {
+        if (this.paymentMethods.getId())
+            await this.paymentMethodsTable.update(this.paymentMethods);
+        else
+            await this.paymentMethodsTable.insert(this.paymentMethods);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/PaymentStatusMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import PaymentStatus from "../stockObjects/PaymentStatus";
+export default class PaymentStatusMapper implements StockObjectMapper {
+    private paymentStatus;
+    private paymentStatusesTable;
+    constructor(paymentStatus: PaymentStatus);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PaymentStatusMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PaymentStatusMapper {
+    paymentStatus;
+    paymentStatusesTable;
+    constructor(paymentStatus) {
+        this.paymentStatusesTable = DatabaseConnection.getInstance().paymentStatuses;
+        this.paymentStatus = paymentStatus;
+    }
+    async save() {
+        await this.paymentStatusesTable.insert(this.paymentStatus);
+    }
+    async delete() {
+        throw Error('Method not implemented');
+    }
+}

package/dist/mappers/PersonalDataMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import PersonalData from "../stockObjects/PersonalData";
+export default class PersonalDataMapper implements StockObjectMapper {
+    private personalData;
+    private personalDataTable;
+    constructor(personalData: PersonalData);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/PersonalDataMapper.js

@@ -0,0 +1,22 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class PersonalDataMapper {
+    personalData;
+    personalDataTable;
+    constructor(personalData) {
+        this.personalDataTable = DatabaseConnection.getInstance().personalData;
+        this.personalData = personalData;
+    }
+    async save() {
+        if (this.personalData.getId())
+            await this.personalDataTable.update(this.personalData);
+        else
+            await this.personalDataTable.insert(this.personalData);
+    }
+    async delete() {
+        const id = this.personalData.getId();
+        if (id)
+            await this.personalDataTable.delete(id);
+        else
+            throw Error('Uncreated personalData cannot be deleted');
+    }
+}

package/dist/mappers/ProductMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import Product from "../stockObjects/Product";
+export default class ProductMapper implements StockObjectMapper {
+    private product;
+    private productTable;
+    constructor(product: Product);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/ProductMapper.js

@@ -0,0 +1,20 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class ProductMapper {
+    product;
+    productTable;
+    constructor(product) {
+        this.productTable = DatabaseConnection.getInstance().products;
+        this.product = product;
+    }
+    async save() {
+        if (this.product.getId() && !this.product.getDeleted())
+            await this.productTable.update(this.product);
+        else
+            await this.productTable.insert(this.product);
+    }
+    async delete() {
+        const id = this.product.getId();
+        if (id)
+            await this.productTable.delete(id);
+    }
+}

package/dist/mappers/StatusMapper.d.ts

@@ -0,0 +1,9 @@
+import { StockObjectMapper } from "@dascompany/database";
+import Status from "../stockObjects/Status";
+export default class StatusMapper implements StockObjectMapper {
+    private status;
+    private statusTable;
+    constructor(status: Status);
+    save(): Promise<void>;
+    delete(): Promise<void>;
+}

package/dist/mappers/StatusMapper.js

@@ -0,0 +1,15 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class StatusMapper {
+    status;
+    statusTable;
+    constructor(status) {
+        this.statusTable = DatabaseConnection.getInstance().statuses;
+        this.status = status;
+    }
+    async save() {
+        await this.statusTable.insert(this.status);
+    }
+    async delete() {
+        throw Error('method not implemented');
+    }
+}

package/dist/reader/AccountCartReader.d.ts

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

package/dist/reader/AccountCartReader.js

@@ -0,0 +1,25 @@
+import { ParameterType, QueryOptions } from "@dascompany/database";
+import DatabaseConnection from "../DatabaseConnection";
+export default class AccountCartReader {
+    static async getAll(accountId) {
+        const queryOptions = new QueryOptions();
+        queryOptions.setWhere([{ name: 'account_id', type: ParameterType.bigint, value: accountId }]);
+        const accountCart = await DatabaseConnection.getInstance().accountCart.select(queryOptions);
+        return this.correctAccountCart(accountCart);
+    }
+    static async get(queryOptions) {
+        const accountCart = await DatabaseConnection.getInstance().accountCart.select(queryOptions);
+        return this.correctAccountCart(accountCart);
+    }
+    static async correctAccountCart(accountCart) {
+        const correctAccountCart = [];
+        for (let i = 0; i < accountCart.length; i++) {
+            correctAccountCart.push({
+                id: accountCart[i].product_id,
+                installation: accountCart[i].installation,
+                quantity: accountCart[i].quantity
+            });
+        }
+        return correctAccountCart;
+    }
+}

package/dist/reader/AccountCompanyDetailsReader.d.ts

@@ -0,0 +1,5 @@
+import CompanyDetailsI from "../types/CompanyDetailsI";
+export default class AccountCompanyDetailsReader {
+    static getAll(accountId: number): Promise<CompanyDetailsI[]>;
+    private static correctAccountCompanyDetails;
+}

package/dist/reader/AccountCompanyDetailsReader.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+import createQueryOptionsForId from "../utils/createQueryOptionsForId";
+import CompanyDetailsReader from "./CompanyDetailsReader";
+export default class AccountCompanyDetailsReader {
+    static async getAll(accountId) {
+        const accountCompanyDetails = await DatabaseConnection.getInstance().accountCompanyDetails.selectAll(accountId);
+        return this.correctAccountCompanyDetails(accountCompanyDetails);
+    }
+    static async correctAccountCompanyDetails(accountCompanyDetails) {
+        const correctAccountCompanyDetails = [];
+        for (let i = 0; i < accountCompanyDetails.length; i++) {
+            const companyDetails = await CompanyDetailsReader.get(createQueryOptionsForId(accountCompanyDetails[i].company_details_id));
+            correctAccountCompanyDetails.push(companyDetails);
+        }
+        return correctAccountCompanyDetails;
+    }
+}

package/dist/reader/AccountDeliveryDetailsReader.d.ts

@@ -0,0 +1,5 @@
+import DeliveryDetailsI from "../types/DeliveryDetailsI";
+export default class AccountDeliveryDetailsReader {
+    static getAll(accountId: number): Promise<DeliveryDetailsI[]>;
+    private static correctAccountDeliveryDetails;
+}

package/dist/reader/AccountDeliveryDetailsReader.js

@@ -0,0 +1,17 @@
+import DatabaseConnection from "../DatabaseConnection";
+import createQueryOptionsForId from "../utils/createQueryOptionsForId";
+import DeliveryDetailsReader from "./DeliveryDetailsReader";
+export default class AccountDeliveryDetailsReader {
+    static async getAll(accountId) {
+        const accountDeliveryDetails = await DatabaseConnection.getInstance().accountDeliveryDetails.selectAll(accountId);
+        return this.correctAccountDeliveryDetails(accountDeliveryDetails);
+    }
+    static async correctAccountDeliveryDetails(accountDeliveryDetails) {
+        const correctAccountDeliveryDetails = [];
+        for (let i = 0; i < accountDeliveryDetails.length; i++) {
+            const deliveryDetails = await DeliveryDetailsReader.get(createQueryOptionsForId(accountDeliveryDetails[i].delivery_details_id));
+            correctAccountDeliveryDetails.push(deliveryDetails);
+        }
+        return correctAccountDeliveryDetails;
+    }
+}

package/dist/reader/AddressesReader.d.ts

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

package/dist/reader/AddressesReader.js

@@ -0,0 +1,18 @@
+import DatabaseConnection from "../DatabaseConnection";
+export default class AddressesReader {
+    static async get(queryOptions) {
+        const address = await DatabaseConnection.getInstance().addresses.select(queryOptions);
+        return this.getCorrectData(address);
+    }
+    static getCorrectData(address) {
+        return {
+            id: address.id,
+            country: address.country,
+            city: address.city,
+            postalCode: address.postal_code,
+            street: address.street,
+            houseNumber: address.house_number,
+            apartmentNumber: address.apartment_number,
+        };
+    }
+}

package/dist/reader/AdminReader.d.ts

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

package/dist/reader/AdminReader.js

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,39 @@
+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

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

package/dist/reader/CompanyDataReader.js

@@ -0,0 +1,39 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,18 @@
+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

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