api/services/nginx/app/routes/orderInvoicesRoute.php

<?php

namespace routes;

use classes\authentication;
use classes\response;
use classes\router;
use objects\collected_order_invoices_o;
use objects\logs_o;
use objects\users_o;
use traits\route_t;

class orderInvoicesRoute
{
    use route_t;

    public function run(): void
    {
        global /** @var response $response */
        /** @var router $router */
        $router, $response;

        /** Collected order invoices > GET */
        $this->get('/collected-invoices', function () {
            global $response;
            self::requirePermission('list_collected_invoices');
            $user = (new authentication())->get_user();
            if ($user) {
                (new logs_o())->add('orderInvoices', 'global', 1, $user->id, 'LIST_COLLECTED_INVOICES', 'User accessed the list of collected order invoices');
                $collected_order_invoices = new collected_order_invoices_o();
                // Check if the request contains an ID
                if (self::isParametersSet(['id'])) {
                    self::requireType((int)self::getParameter('id'), self::type_int());
                    $collected_order_invoices->select((int)self::getParameter('id'));
                    $collected_order_invoices->requireSelected();
                    $response->success($collected_order_invoices->asArray());
                }
                // Define the users
                $users = new users_o();
                // Define the collected order invoices
                $tmp_collected_order_invoices = new collected_order_invoices_o();
                // Return the list of collected order invoices
                $response->success($collected_order_invoices->listObjectsWithPaginationIfSet(
                    function ($collected_order_invoice) use ($tmp_collected_order_invoices, $users) {
                        // Select the orders for each collected order invoice
                        $tmp_collected_order_invoices->select((int)$collected_order_invoice['id']);
                        return [
                            'id' => (int)$collected_order_invoice['id'],
                            'name' => (string)$collected_order_invoice['name'],
                            'notes' => (string)$collected_order_invoice['notes'],
                            'customer_number' => (int)$collected_order_invoice['customer_number'],
                            'customer_name' => (string)$users->getCustomerName((int)$collected_order_invoice['customer_number']),
                            'processor' => $collected_order_invoice['processor'] ? (int)$collected_order_invoice['processor'] : null,
                            'external_id' => (string)$collected_order_invoice['external_id'],
                            'closed_at' => $collected_order_invoice['closed_at'] ? (string)$collected_order_invoice['closed_at'] : null,
                            'updated_at' => (string)$collected_order_invoice['updated_at'],
                            'created_at' => (string)$collected_order_invoice['created_at'],
                            'orders' => $tmp_collected_order_invoices->getOrders(true),
                            'total_net_amount' => (float)$tmp_collected_order_invoices->getTotalAmount()
                        ];
                    },
                ));
            } else {
                (new logs_o())->add('orderInvoices', 'global', 0, 0, 'LIST_COLLECTED_INVOICES', 'User tried to access the list of collected order invoices without a valid session');
                $response->error('Invalid session', 400);
            }
        },
            [
                'list_collected_invoices' => 'List ALL collected order invoices. This is a superuser-only route.'
            ]
        );

        /** Collected order invoices > Ready to invoice > GET */
        $this->get('/collected-invoices/ready-to-invoice', function () {
            global $response;
            self::requirePermission('list_collected_invoices');
            $user = (new authentication())->get_user();
            if ($user) {
                (new logs_o())->add('orderInvoices', 'global', 1, $user->id, 'LIST_COLLECTED_INVOICES_READY_TO_INVOICE', 'User accessed the list of collected order invoices ready to invoice');
                $collected_order_invoices = new collected_order_invoices_o();
                // Define the users
                $users = new users_o();
                // Define the collected order invoices
                $tmp_collected_order_invoices = new collected_order_invoices_o();
                // Return the list of collected order invoices
                $response->success($collected_order_invoices->listObjectsWithPaginationIfSet(
                    function ($collected_order_invoice) use ($tmp_collected_order_invoices, $users) {
                        // Select the orders for each collected order invoice
                        $tmp_collected_order_invoices->select((int)$collected_order_invoice['id']);
                        return [
                            'id' => (int)$collected_order_invoice['id'],
                            'name' => (string)$collected_order_invoice['name'],
                            'notes' => (string)$collected_order_invoice['notes'],
                            'customer_number' => (int)$collected_order_invoice['customer_number'],
                            'customer_name' => (string)$users->getCustomerName((int)$collected_order_invoice['customer_number']),
                            'processor' => $collected_order_invoice['processor'] ? (int)$collected_order_invoice['processor'] : null,
                            'external_id' => (string)$collected_order_invoice['external_id'],
                            'closed_at' => $collected_order_invoice['closed_at'] ? (string)$collected_order_invoice['closed_at'] : null,
                            'updated_at' => (string)$collected_order_invoice['updated_at'],
                            'created_at' => (string)$collected_order_invoice['created_at'],
                            'orders' => $tmp_collected_order_invoices->getOrders(true),
                            'total_net_amount' => (float)$tmp_collected_order_invoices->getTotalAmount(),
                        ];
                    },
                    $collected_order_invoices->forceRestrictFilters(
                        [
                            // This makes sure that the user can only see orders from the departments they explicitly have access to
                            'customer_number' => $collected_order_invoices->listCustomersWithIndividualOrderInvoicing(),
                        ]
                    )
                ));
            } else {
                (new logs_o())->add('orderInvoices', 'global', 0, 0, 'LIST_COLLECTED_INVOICES_READY_TO_INVOICE', 'User tried to access the list of collected order invoices ready to invoice without a valid session');
                $response->error('Invalid session', 400);
            }
        },
            [
                'list_collected_invoices' => 'List ALL collected order invoices. This is a superuser-only route.'
            ]
        );

        /** Collected order invoices > POST */
        $this->post('/collected-invoices', function () {
            global $response;
            self::requirePermission('add_collected_invoice');
            $user = (new authentication())->get_user();
            if ($user) {
                (new logs_o())->add('orderInvoices', 'global', 1, $user->id, 'ADD_COLLECTED_INVOICE', 'User added a collected order invoice');
                // Require the customer number, and validate its type and length
                self::requireParameters(['customer_number']);
                self::requireType((int)self::getParameter('customer_number'), 'int');
                self::requireMinLength('customer_number', 1);
                self::requireMaxLength('customer_number', 10);
                // Require the customer number to be above 0
                self::requireMinValue((int)self::getParameter('customer_number'), 1);
                // Validate the customer number against the database
                $customer = (new users_o())->select((int)self::getParameter('customer_number'));
                $customer->requireSelected();
                // Define the variables
                $name = null;
                $notes = null;
                $processor = null;
                // Check if the name is set
                if (self::isParametersSet(['name'])) {
                    self::requireType((string)self::getParameter('name'), 'string');
                    self::requireMinLength('name', 1);
                    self::requireMaxLength('name', 255);
                    $name = (string)self::getParameter('name');
                }
                // Check if the notes are set
                if (self::isParametersSet(['notes'])) {
                    self::requireType((string)self::getParameter('notes'), 'string');
                    $notes = (string)self::getParameter('notes');
                }
                // Check if the processor is set
                if (self::isParametersSet(['processor'])) {
                    self::requireType((int)self::getParameter('processor'), 'int');
                    $processor = (int)self::getParameter('processor');
                }
                // Add the collected order invoice
                $collected_order_invoices = new collected_order_invoices_o();
                $collected_order_invoices->add(
                    $customer->id,
                    $name,
                    $notes,
                    $processor
                );
                $response->success($collected_order_invoices->asArray());
            } else {
                (new logs_o())->add('orderInvoices', 'global', 0, 0, 'ADD_COLLECTED_INVOICE', 'User tried to add a collected order invoice without a valid session');
                $response->error('Invalid session', 400);
            }
        },
            [
                'add_collected_invoice' => 'Add a collected order invoice. This is a superuser-only route.'
            ]
        );

        /** Collected order invoices > E-Conomic > POST */
        $this->post('/collected-invoices/economic', function () {
            global $response;
            self::requirePermission('add_collected_invoice_economic');
            $user = (new authentication())->get_user();
            if ($user) {
                (new logs_o())->add('orderInvoices', 'global', 1, $user->id, 'ADD_COLLECTED_INVOICE_ECONOMIC', 'User added a collected order invoice to E-Conomic');
                // Require the ID, and validate its type and length
                self::requireParameters(['id']);
                self::requireType((int)self::getParameter('id'), self::type_int());
                self::requireMinLength('id', 1);
                self::requireMaxLength('id', 10);
                // Require the ID to be above 0
                self::requireMinValue((int)self::getParameter('id'), 1);
                // Validate the ID against the database
                $collected_order_invoices = (new collected_order_invoices_o())->select((int)self::getParameter('id'));
                $collected_order_invoices->requireSelected();
                // Check if the collected order invoice has an external ID
                if ($collected_order_invoices->external_id->value() === null) {
                    // Add the collected order invoice to E-Conomic
                    $collected_order_invoices->addToEconomic();
                    $response->success($collected_order_invoices->asArray());
                }
                // Check if the invoice has been booked
                if ($collected_order_invoices->booked_invoice_id->value() !== null) {
                    $response->error('Invoice has already been booked', 400);
                }
                // Check if the invoice draft exists in E-Conomic
                if ($collected_order_invoices->isDraftExisting()) {
                    $response->error('Invoice draft already exists in E-Conomic', 400);
                }
                // Create the invoice in E-Conomic
                $collected_order_invoices->addToEconomic(true);
                // Return the collected order invoice
                $response->success($collected_order_invoices->asArray());
            } else {
                (new logs_o())->add('orderInvoices', 'global', 0, 0, 'ADD_COLLECTED_INVOICE_ECONOMIC', 'User tried to add a collected order invoice to E-Conomic without a valid session');
                $response->error('Invalid session', 400);
            }
        },
            [
                'add_collected_invoice_economic' => 'Add a collected order invoice to E-Conomic. This is a superuser-only route.'
            ]
        );
    }
}