@dascompany/product 1.0.0

package/dist/mappers/ClientMapper.d.ts

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

package/dist/mappers/ClientMapper.js

@@ -0,0 +1,24 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class ClientMapper {
+    client;
+    clientAccountsTable;
+    constructor(client) {
+        this.clientAccountsTable = ProductConnectionFactory.get().productsSchema.clientAccounts;
+        this.client = client;
+    }
+    async save() {
+        if (!this.client.getDeleted()) {
+            if (this.client.getId())
+                await this.clientAccountsTable.update(this.client);
+            else
+                await this.clientAccountsTable.insert(this.client);
+        }
+        else
+            throw new Error(`Client account ${this.client.getId()} is deleted. Restore before updating.`);
+    }
+    async delete() {
+        const id = this.client.getId();
+        if (id)
+            await this.clientAccountsTable.delete(id);
+    }
+}

package/dist/mappers/CompanyDataMapper.d.ts

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

package/dist/mappers/CompanyDataMapper.js

@@ -0,0 +1,17 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class CompanyDataMapper {
+    companyData;
+    companyDataTable;
+    constructor(companyData) {
+        this.companyDataTable = ProductConnectionFactory.get().productsSchema.companyData;
+        this.companyData = companyData;
+    }
+    async save() {
+        if (this.companyData.getId())
+            await this.companyDataTable.update(this.companyData);
+        else
+            await this.companyDataTable.insert(this.companyData);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/CompanyDetailsMapper.d.ts

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

package/dist/mappers/CompanyDetailsMapper.js

@@ -0,0 +1,22 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class CompanyDetailsMapper {
+    companyDetails;
+    companyDetailsTable;
+    constructor(companyDetails) {
+        this.companyDetailsTable = ProductConnectionFactory.get().productsSchema.companyDetails;
+        this.companyDetails = companyDetails;
+    }
+    async save() {
+        if (this.companyDetails.getId())
+            await this.companyDetailsTable.update(this.companyDetails);
+        else
+            await this.companyDetailsTable.insert(this.companyDetails);
+    }
+    async delete() {
+        const id = this.companyDetails.getId();
+        if (id)
+            await this.companyDetailsTable.delete(id);
+        else
+            throw Error('Uncreated companyDetails cannot be deleted');
+    }
+}

package/dist/mappers/ContactDetailsMapper.d.ts

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

package/dist/mappers/ContactDetailsMapper.js

@@ -0,0 +1,18 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class ContactDetailsMapper {
+    contactDetails;
+    contactDetailsTable;
+    constructor(contactDetails) {
+        this.contactDetailsTable = ProductConnectionFactory.get().productsSchema.contactDetails;
+        this.contactDetails = contactDetails;
+    }
+    async save() {
+        if (this.contactDetails.getId())
+            await this.contactDetailsTable.update(this.contactDetails);
+        else
+            await this.contactDetailsTable.insert(this.contactDetails);
+    }
+    async delete() {
+        throw Error('Method not impemented');
+    }
+}

package/dist/mappers/DeliveryDetailsMapper.d.ts

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

package/dist/mappers/DeliveryDetailsMapper.js

@@ -0,0 +1,17 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class DeliveryDetailsMapper {
+    deliveryDetails;
+    deliveryDetailsTable;
+    constructor(deliveryDetails) {
+        this.deliveryDetailsTable = ProductConnectionFactory.get().productsSchema.deliveryDetails;
+        this.deliveryDetails = deliveryDetails;
+    }
+    async save() {
+        if (this.deliveryDetails.getId())
+            await this.deliveryDetailsTable.update(this.deliveryDetails);
+        else
+            await this.deliveryDetailsTable.insert(this.deliveryDetails);
+    }
+    async delete() {
+    }
+}

package/dist/mappers/DeliveryMethodsMapper.d.ts

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

package/dist/mappers/DeliveryMethodsMapper.js

@@ -0,0 +1,17 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class DeliveryMethodsMapper {
+    deliveryMethods;
+    deliveryMethodsTable;
+    constructor(deliveryMethods) {
+        this.deliveryMethodsTable = ProductConnectionFactory.get().productsSchema.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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class DeliveryStatusMapper {
+    deliveryStatus;
+    deliveryStatusesTable;
+    constructor(deliveryStatus) {
+        this.deliveryStatusesTable = ProductConnectionFactory.get().productsSchema.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,17 @@
+import ProductConnectionFactory from '../ProductConnectionFactory';
+export default class FileConnectionMapper {
+    fileConnection;
+    fileConnectionsTable;
+    constructor(fileConnection) {
+        this.fileConnectionsTable = ProductConnectionFactory.get().productsSchema.fileConnections;
+        this.fileConnection = fileConnection;
+    }
+    async save() {
+        const id = this.fileConnection.getId();
+        if (id)
+            await this.fileConnectionsTable.delete(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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class FileMapper {
+    file;
+    filesTable;
+    constructor(file) {
+        this.filesTable = ProductConnectionFactory.get().productsSchema.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/InvoiceDetailsMapper.d.ts

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

package/dist/mappers/InvoiceDetailsMapper.js

@@ -0,0 +1,17 @@
+import ProductConnectionFactory from '../ProductConnectionFactory';
+export default class InvoiceDetailsMapper {
+    invoiceDetails;
+    invoiceDetailsTable;
+    constructor(invoiceDetails) {
+        this.invoiceDetailsTable = ProductConnectionFactory.get().productsSchema.invoiceDetails;
+        this.invoiceDetails = invoiceDetails;
+    }
+    async save() {
+        if (this.invoiceDetails.getId())
+            await this.invoiceDetailsTable.update(this.invoiceDetails);
+        else
+            await this.invoiceDetailsTable.insert(this.invoiceDetails);
+    }
+    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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class OrderMapper {
+    order;
+    orderTable;
+    constructor(order) {
+        this.orderTable = ProductConnectionFactory.get().productsSchema.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,15 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class OrderProductMapper {
+    orderProduct;
+    orderProductsTable;
+    constructor(orderProduct) {
+        this.orderProductsTable = ProductConnectionFactory.get().productsSchema.ordersProducts;
+        this.orderProduct = orderProduct;
+    }
+    async save() {
+        await this.orderProductsTable.insert(this.orderProduct);
+    }
+    async delete() {
+        throw Error('NOT IMPLEMENTED');
+    }
+}

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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class PaymentDetailsMapper {
+    paymentDetails;
+    paymentDetailsTable;
+    constructor(paymentDetails) {
+        this.paymentDetailsTable = ProductConnectionFactory.get().productsSchema.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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class PaymentMethodsMapper {
+    paymentMethods;
+    paymentMethodsTable;
+    constructor(paymentMethods) {
+        this.paymentMethodsTable = ProductConnectionFactory.get().productsSchema.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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class PaymentStatusMapper {
+    paymentStatus;
+    paymentStatusesTable;
+    constructor(paymentStatus) {
+        this.paymentStatusesTable = ProductConnectionFactory.get().productsSchema.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,17 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class PersonalDataMapper {
+    personalData;
+    personalDataTable;
+    constructor(personalData) {
+        this.personalDataTable = ProductConnectionFactory.get().productsSchema.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() {
+    }
+}

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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class ProductMapper {
+    product;
+    productTable;
+    constructor(product) {
+        this.productTable = ProductConnectionFactory.get().productsSchema.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 ProductConnectionFactory from "../ProductConnectionFactory";
+export default class StatusMapper {
+    status;
+    statusTable;
+    constructor(status) {
+        this.statusTable = ProductConnectionFactory.get().productsSchema.statuses;
+        this.status = status;
+    }
+    async save() {
+        await this.statusTable.insert(this.status);
+    }
+    async delete() {
+        throw Error('method not implemented');
+    }
+}

package/dist/reader/AddressesReader.d.ts

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

package/dist/reader/AddressesReader.js

@@ -0,0 +1,24 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class AddressesReader {
+    static async get(addressId) {
+        const connection = ProductConnectionFactory.get();
+        const address = await connection.productsSchema.addresses.select(addressId);
+        return this.getCorrectData(address);
+    }
+    static async getCompanyAddress() {
+        const connection = ProductConnectionFactory.get();
+        const address = await connection.productsSchema.addresses.select(1);
+        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,12 @@
+import { QueryOptionsI } from "@dascompany/database";
+import AdminI from "../types/AdminI";
+export default class AdminReader {
+    static get(accountId: number): Promise<AdminI>;
+    static getIdForEmail(email: string): Promise<number>;
+    static getAll(queryOptions: QueryOptionsI): Promise<{
+        adminAccounts: AdminI[];
+        quantity: number;
+    }>;
+    private static correctAdmins;
+    private static correctAdmin;
+}

package/dist/reader/AdminReader.js

@@ -0,0 +1,40 @@
+import ProductConnectionFactory from "../ProductConnectionFactory";
+export default class AdminReader {
+    static async get(accountId) {
+        const connection = ProductConnectionFactory.get();
+        const account = await connection.productsSchema.adminAccounts.select(accountId);
+        return this.correctAdmin(account);
+    }
+    static async getIdForEmail(email) {
+        const connection = ProductConnectionFactory.get();
+        return await connection.productsSchema.adminAccounts.selectForEmail(email);
+    }
+    static async getAll(queryOptions) {
+        const connection = ProductConnectionFactory.get();
+        const adminAccounts = await connection.productsSchema.adminAccounts.selectAll(queryOptions);
+        const quantity = await connection.productsSchema.adminAccounts.count(queryOptions);
+        return {
+            adminAccounts: this.correctAdmins(adminAccounts),
+            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,13 @@
+import { QueryOptions } from "@dascompany/database";
+import ClientAccountI from "../types/ClientAccountI";
+export default class ClientAccountReader {
+    static get(accountId: number): Promise<ClientAccountI>;
+    static getAll(queryOptions: QueryOptions): Promise<{
+        clientAccounts: ClientAccountI[];
+        quantity: number;
+    }>;
+    static getForEmail(email: string): Promise<ClientAccountI>;
+    static getIdForEmail(email: string): Promise<number>;
+    private static correctClientsFromRows;
+    private static correctData;
+}