@dascompany/database 0.0.1

package/dist/stockObjects/Product.js

@@ -0,0 +1,101 @@
+import FilesReader from "../reader/FilesReader";
+import FileConnectionE from "../types/FileConnectionE";
+import StockObject from "../types/StockObject";
+import calculateNetToGrossPrice from "../utils/calculateNetToGrossPrice";
+export default class Product extends StockObject {
+    sku;
+    url;
+    title;
+    description;
+    netPrice;
+    vat;
+    color;
+    quantity;
+    width;
+    length;
+    height;
+    fileId;
+    deleted;
+    createdAt;
+    file;
+    files;
+    constructor(sku, url, title, description, netPrice, vat, color, quantity, width, length, height, fileId, deleted = false) {
+        super();
+        this.sku = sku;
+        this.url = url;
+        this.title = title;
+        this.description = description;
+        this.netPrice = netPrice;
+        this.vat = vat;
+        this.color = color;
+        this.quantity = quantity;
+        this.width = width;
+        this.length = length;
+        this.height = height;
+        this.fileId = fileId;
+        this.deleted = deleted;
+        this.createdAt = null;
+        this.file = null;
+        this.files = null;
+    }
+    getSku() {
+        return this.sku;
+    }
+    getUrl() {
+        return this.url;
+    }
+    getTitle() {
+        return this.title;
+    }
+    getDescription() {
+        return this.description;
+    }
+    getNetPrice() {
+        return calculateNetToGrossPrice(this.netPrice, this.vat);
+    }
+    getGrossPrice() {
+        return this.netPrice;
+    }
+    getVat() {
+        return this.vat;
+    }
+    getColor() {
+        return this.color;
+    }
+    getQuantity() {
+        return this.quantity;
+    }
+    getWidth() {
+        return this.width;
+    }
+    getLength() {
+        return this.length;
+    }
+    getHeight() {
+        return this.height;
+    }
+    getFileId() {
+        return this.fileId;
+    }
+    getDeleted() {
+        return this.deleted;
+    }
+    async getFile() {
+        if (!this.file && this.fileId)
+            this.file = await FilesReader.get(this.fileId);
+        return this.file;
+    }
+    async getFiles() {
+        if (!this.files) {
+            const files = await FilesReader.getForConnection(FileConnectionE.product, this.getId());
+            this.files = files;
+        }
+        return this.files;
+    }
+    setCreatedAt(createdAt) {
+        this.createdAt = createdAt;
+    }
+    getMapper() {
+        throw new Error('there are no mapper for product');
+    }
+}

package/dist/stockObjects/Status.d.ts

@@ -0,0 +1,15 @@
+import StockObject from "../types/StockObject";
+import StockObjectMapper from "../types/StockObjectMapper";
+export default class Status extends StockObject {
+    private orderId;
+    private userId;
+    private type;
+    constructor(orderId: number, userId: number, type: number);
+    getOrderId(): number;
+    getUserId(): number;
+    getType(): number;
+    setUserId(userId: number): void;
+    setType(type: number): void;
+    setOrderId(orderId: number): void;
+    protected getMapper(): StockObjectMapper;
+}

package/dist/stockObjects/Status.js

@@ -0,0 +1,34 @@
+import StatusMapper from "../mappers/StatusMapper";
+import StockObject from "../types/StockObject";
+export default class Status extends StockObject {
+    orderId;
+    userId;
+    type;
+    constructor(orderId, userId, type) {
+        super();
+        this.orderId = orderId;
+        this.userId = userId;
+        this.type = type;
+    }
+    getOrderId() {
+        return this.orderId;
+    }
+    getUserId() {
+        return this.userId;
+    }
+    getType() {
+        return this.type;
+    }
+    setUserId(userId) {
+        this.userId = userId;
+    }
+    setType(type) {
+        this.type = type;
+    }
+    setOrderId(orderId) {
+        this.orderId = orderId;
+    }
+    getMapper() {
+        return new StatusMapper(this);
+    }
+}

package/dist/tables/AdminAccountsTable.d.ts

@@ -0,0 +1,15 @@
+import QueryOptionsI from "../types/QueryOptionsI";
+import Table from "../Table";
+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>;
+    insert(admin: Admin): Promise<number>;
+    update(admin: Admin): Promise<boolean>;
+    delete(accountId: number): Promise<number>;
+    private bindParameters;
+    private selectNextId;
+}

package/dist/tables/AdminAccountsTable.js

@@ -0,0 +1,64 @@
+import Table from "../Table";
+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);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.selectAll, 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());
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async count(queryOptions) {
+        const query = this.createQuery(SQL.adminAccounts.count, queryOptions);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async insert(admin) {
+        let accountId = await this.selectForEmail(admin.getEmail());
+        if (accountId)
+            throw new Error(`Admin account with email: ${admin.getEmail()} already exist!`);
+        else
+            accountId = await this.selectNextId();
+        const query = this.createQuery(SQL.adminAccounts.insert);
+        query.bindParameter('id', accountId);
+        this.bindParameters(query, admin);
+        await query.execute();
+        admin.setId(accountId);
+        return accountId;
+    }
+    async update(admin) {
+        const query = this.createQuery(SQL.adminAccounts.update);
+        query.bindParameter('id', admin.getId());
+        this.bindParameters(query, admin);
+        await query.execute();
+        return true;
+    }
+    async delete(accountId) {
+        const query = this.createQuery(SQL.adminAccounts.delete);
+        query.bindParameter('id', accountId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    bindParameters(query, admin) {
+        query.bindParameter('email', admin.getEmail());
+        query.bindParameter('first_name', admin.getFirstName());
+        query.bindParameter('last_name', admin.getLastName());
+        query.bindParameter('activated', admin.getActivated());
+        query.bindParameter('deleted', admin.getDeleted());
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.adminAccounts.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/ClientAccountsTable.d.ts

@@ -0,0 +1,14 @@
+import Table from '../Table';
+import ClientAccountRow from '../types/rows/ClientAccountRow';
+import Client from '../stockObjects/Client';
+export default class ClientAccountsTable extends Table {
+    select(accountId: number): Promise<ClientAccountRow>;
+    selectForEmail(email: string): Promise<ClientAccountRow>;
+    selectIdForEmail(email: string): Promise<number>;
+    update(clientData: Client): Promise<void>;
+    delete(accountId: number): Promise<number>;
+    private bindParameters;
+    insert(clientAccount: Client): Promise<void>;
+    private getIdForEmail;
+    private selectNextId;
+}

package/dist/tables/ClientAccountsTable.js

@@ -0,0 +1,62 @@
+import Table from '../Table';
+import * as SQL from '../SQL.json';
+export default class ClientAccountsTable extends Table {
+    async select(accountId) {
+        const query = this.createQuery(SQL.accounts.select);
+        query.bindParameter('account_id', accountId);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectForEmail(email) {
+        const id = await this.getIdForEmail(email);
+        return await this.select(id);
+    }
+    async selectIdForEmail(email) {
+        const id = await this.getIdForEmail(email);
+        return id;
+    }
+    async update(clientData) {
+        const query = this.createQuery(SQL.accounts.update);
+        query.bindParameter('id', clientData.getId());
+        this.bindParameters(query, clientData);
+        await query.execute();
+    }
+    async delete(accountId) {
+        const query = this.createQuery(SQL.accounts.delete);
+        query.bindParameter('account_id', accountId);
+        const result = await query.execute();
+        return result.getRowCount();
+    }
+    bindParameters(query, clientAccount) {
+        query.bindParameter('activated', clientAccount.getActivated());
+        query.bindParameter('deleted', clientAccount.getDeleted());
+        query.bindParameter('contact_details_id', clientAccount.getContactDetailsId());
+        query.bindParameter('delivery_details_id', clientAccount.getDeliveryDetailsId());
+        query.bindParameter('invoice_details_id', clientAccount.getInvoiceDetailsId());
+    }
+    async insert(clientAccount) {
+        const clientEmail = clientAccount.getEmail();
+        let accountId = await this.getIdForEmail(clientEmail);
+        if (accountId)
+            throw new Error(`Client account with email: ${clientEmail} already exist!`);
+        else
+            accountId = await this.selectNextId();
+        const query = this.createQuery(SQL.accounts.insert);
+        query.bindParameter('id', accountId);
+        query.bindParameter('email', clientEmail);
+        this.bindParameters(query, clientAccount);
+        await query.execute();
+        clientAccount.setId(accountId);
+    }
+    async getIdForEmail(email) {
+        const query = this.createQuery(SQL.accounts.getIdForEmail);
+        query.bindParameter('email', String(email).toUpperCase());
+        const result = await query.execute();
+        return result.getValue();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.accounts.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/DeliveryStatusTypesTable.d.ts

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

package/dist/tables/DeliveryStatusTypesTable.js

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

package/dist/tables/DeliveryStatusesTable.d.ts

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

package/dist/tables/DeliveryStatusesTable.js

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

package/dist/tables/ProductsTable.d.ts

@@ -0,0 +1,9 @@
+import Table from '../Table';
+import QueryOptionsI from '../types/QueryOptionsI';
+import ProductRow from '../types/rows/ProductRow';
+export default class ProductsTable extends Table {
+    select(productId: number): Promise<ProductRow>;
+    selectAll(queryOption: QueryOptionsI): Promise<ProductRow[]>;
+    selectForUrl(url: string): Promise<ProductRow>;
+    count(queryOption: QueryOptionsI): Promise<number>;
+}

package/dist/tables/ProductsTable.js

@@ -0,0 +1,26 @@
+import Table from '../Table';
+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);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(queryOption) {
+        const query = this.createQuery(SQL.products.selectAll, queryOption);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async selectForUrl(url) {
+        const query = this.createQuery(SQL.products.selectForUrl);
+        query.bindParameter('url', url.toUpperCase());
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async count(queryOption) {
+        const query = this.createQuery(SQL.products.count, queryOption);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

package/dist/tables/StatusTypesTable.d.ts

@@ -0,0 +1,4 @@
+import Table from "../Table";
+export default class StatusTypesTable extends Table {
+    select(): Promise<any[]>;
+}

package/dist/tables/StatusTypesTable.js

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

package/dist/tables/files/FilesTable.d.ts

@@ -0,0 +1,7 @@
+import Table from '../../Table';
+import FileRow from '../../types/rows/FileRow';
+import FileConnectionE from '../../types/FileConnectionE';
+export default class FilesTable extends Table {
+    select(fileId: number): Promise<FileRow>;
+    selectForConnection(connectionType: FileConnectionE, connectionId: number): Promise<FileRow[]>;
+}

package/dist/tables/files/FilesTable.js

@@ -0,0 +1,17 @@
+import Table from '../../Table';
+import * as SQL from '../../SQL.json';
+export default class FilesTable extends Table {
+    async select(fileId) {
+        const query = this.createQuery(SQL.files.select);
+        query.bindParameter('id', fileId);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectForConnection(connectionType, connectionId) {
+        const query = this.createQuery(SQL.files.selectForConnection);
+        query.bindParameter('connection_type', connectionType);
+        query.bindParameter('connection_id', connectionId);
+        const result = await query.execute();
+        return result.getRows();
+    }
+}

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

@@ -0,0 +1,8 @@
+import Table from '../../Table';
+import OrderProductRow from '../../types/rows/OrderProductRow';
+import OrderProduct from '../../stockObjects/OrderProduct';
+export default class OrdersProductsTable extends Table {
+    selectAll(orderId: number): Promise<OrderProductRow[]>;
+    insert(orderProduct: OrderProduct): Promise<void>;
+    private selectNextId;
+}

package/dist/tables/orders/OrdersProductsTable.js

@@ -0,0 +1,25 @@
+import Table from '../../Table';
+import * as SQL from '../../SQL.json';
+export default class OrdersProductsTable extends Table {
+    async selectAll(orderId) {
+        const query = this.createQuery(SQL.ordersProducts.selectForOrder);
+        query.bindParameter('order_id', orderId);
+        const results = await query.execute();
+        return results.getRows();
+    }
+    async insert(orderProduct) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.ordersProducts.insert);
+        query.bindParameter('id', id);
+        query.bindParameter('order_id', orderProduct.getOrderId());
+        query.bindParameter('product_id', orderProduct.getProductId());
+        query.bindParameter('net_price', orderProduct.getNetPrice());
+        await query.execute();
+        orderProduct.setId(id);
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.ordersProducts.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

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

@@ -0,0 +1,12 @@
+import Table from '../../Table';
+import OrderRow from '../../types/rows/OrderRow';
+import Order from '../../stockObjects/Order';
+export default class OrdersTable extends Table {
+    select(orderId: number): Promise<OrderRow>;
+    selectForClient(clientId: number): Promise<OrderRow[]>;
+    insert(order: Order): Promise<void>;
+    update(order: Order): Promise<void>;
+    private bindParameters;
+    private bindDetailsParameters;
+    private selectNextId;
+}

package/dist/tables/orders/OrdersTable.js

@@ -0,0 +1,50 @@
+import Table from '../../Table';
+import * as SQL from '../../SQL.json';
+export default class OrdersTable extends Table {
+    async select(orderId) {
+        const query = this.createQuery(SQL.orders.select);
+        query.bindParameter('id', orderId);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectForClient(clientId) {
+        const query = this.createQuery(SQL.orders.selectForClient);
+        query.bindParameter('client_id', clientId);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(order) {
+        const orderId = await this.selectNextId();
+        const query = this.createQuery(SQL.orders.insert);
+        query.bindParameter('order_id', orderId);
+        this.bindParameters(query, order);
+        await query.execute();
+        order.setId(orderId);
+    }
+    async update(order) {
+        const orderId = order.getId();
+        const query = this.createQuery(SQL.orders.update);
+        query.bindParameter('id', orderId);
+        query.bindParameter('price', order.getPrice());
+        query.bindParameter('zsi_id', order.getZsiId());
+        this.bindDetailsParameters(query, order);
+        await query.execute();
+    }
+    bindParameters(query, order) {
+        query.bindParameter('email', order.getEmail());
+        query.bindParameter('price', order.getPrice());
+        query.bindParameter('client_id', order.getclientId());
+        this.bindDetailsParameters(query, order);
+    }
+    bindDetailsParameters(query, order) {
+        query.bindParameter('contact_details_id', order.getContactDetailsId());
+        query.bindParameter('delivery_details_id', order.getDeliveryDetailsId());
+        query.bindParameter('invoice_details_id', order.getInvoiceDetailsId());
+        query.bindParameter('payment_details_id', order.getPaymentDetailsId());
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.orders.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}

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

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

package/dist/tables/orders/PaymentDetailsTable.js

@@ -0,0 +1,34 @@
+import Table from '../../Table';
+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);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async insert(paymentDetails) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.paymentDetails.insert);
+        query.bindParameter('id', id);
+        this.bindParameters(query, paymentDetails);
+        await query.execute();
+        paymentDetails.setId(id);
+    }
+    async update(paymentDetails) {
+        const id = paymentDetails.getId();
+        const query = this.createQuery(SQL.paymentDetails.update);
+        query.bindParameter('id', id);
+        this.bindParameters(query, paymentDetails);
+        await query.execute();
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.paymentDetails.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+    bindParameters(query, paymentDetails) {
+        query.bindParameter('payment_method_id', paymentDetails.getPaymentMethodId());
+        query.bindParameter('payment_order_id', paymentDetails.getPaymentOrderId());
+    }
+}

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

@@ -0,0 +1,7 @@
+import Table from '../../Table';
+export default class PaymentStatusTypesTable extends Table {
+    select(paymentStatusTypeId: number): Promise<{
+        id: number;
+        value: string;
+    }>;
+}

package/dist/tables/orders/PaymentStatusTypesTable.js

@@ -0,0 +1,10 @@
+import * as SQL from '../../SQL.json';
+import Table from '../../Table';
+export default class PaymentStatusTypesTable extends Table {
+    async select(paymentStatusTypeId) {
+        const query = this.createQuery(SQL.paymentStatusTypes.select);
+        query.bindParameter('id', paymentStatusTypeId);
+        const result = await query.execute();
+        return result.getRow();
+    }
+}

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

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

package/dist/tables/orders/PaymentStatusesTable.js

@@ -0,0 +1,30 @@
+import * as SQL from '../../SQL.json';
+import Table from '../../Table';
+export default class PaymentStatusesTable extends Table {
+    async select(paymentDetailsId) {
+        const query = this.createQuery(SQL.paymentStatuses.select);
+        query.bindParameter('payment_details_id', paymentDetailsId);
+        const result = await query.execute();
+        return result.getRow();
+    }
+    async selectAll(paymentDetailsId) {
+        const query = this.createQuery(SQL.paymentStatuses.selectAll);
+        query.bindParameter('payment_details_id', paymentDetailsId);
+        const result = await query.execute();
+        return result.getRows();
+    }
+    async insert(paymentStatus) {
+        const id = await this.selectNextId();
+        const query = this.createQuery(SQL.paymentStatuses.insert);
+        query.bindParameter('id', id);
+        query.bindParameter('payment_details_id', paymentStatus.getPaymentDetailsId());
+        query.bindParameter('payment_status_type_id', paymentStatus.getPaymentStatusTypeId());
+        await query.execute();
+        paymentStatus.setId(id);
+    }
+    async selectNextId() {
+        const query = this.createQuery(SQL.paymentStatuses.selectNextId);
+        const result = await query.execute();
+        return result.getValue();
+    }
+}