ui5_easy_use/dist/ez5/package-content/api/content/OdataV4.js

CLI tool for SAP ui5 and SAPUI5 projects to initialize apps, generate pages, insert form and table components, manage routing, and automate i18n bindings

sap.ui.define([], function () {
    "use strict";

    return class OdataV4 {
        constructor(controller) {
            this._controller = controller;
        }

        init() {
        }

        async GET(model, entitySet, filters = null, select = null, expand = null, skip = 0, top = Number.MAX_SAFE_INTEGER) {
            this._assertListRequest(model, entitySet, skip, top);

            try {
                const listBinding = model.bindList(
                    entitySet,
                    undefined,
                    undefined,
                    filters,
                    this._buildQueryOptions(select, expand)
                );
                const contexts = await listBinding.requestContexts(skip, top);
                return contexts.map((context) => context.getObject());
            } catch (error) {
                this._showMessageBoxError("Data Fetch Error", error.cause?.message || "An error occurred while fetching data.");
                throw error;
            }
        }

        async GETExtr(model, entitySet, parameters = []) {
            if (!model) {
                throw new Error("OData model is not available.");
            }

            const actionBinding = model.bindContext(`/${entitySet}(...)`);
            parameters.forEach(function (parameter) {
                actionBinding.setParameter(parameter.key, parameter.value);
            });

            try {
                await actionBinding.execute();
                return actionBinding.getBoundContext().getObject().value;
            } catch (error) {
                console.error(`Failed to execute OData action for ${entitySet}.`, error);
                throw error;
            }
        }

        async POST(model, entitySet, newData) {
            try {
                const createBinding = model.bindList(entitySet);
                const createdContext = await createBinding.create(newData);

                if (createdContext?.getObject) {
                    return createdContext.getObject();
                }

                return await this._findCreatedRecord(model, entitySet, newData);
            } catch (error) {
                console.error(`Error creating entity in ${entitySet}.`, error);
                throw error;
            }
        }

        async PUT(model, entitySet, filters, updatedData) {
            try {
                const context = await this._findFirstContext(model, entitySet, filters);

                if (!context) {
                    this._showToast("No matching record found.");
                    return;
                }

                Object.entries(updatedData || {}).forEach(function ([key, value]) {
                    context.setProperty(key, value);
                });
                this._showToast("Record updated successfully!");
            } catch (error) {
                this._showMessageBoxError("Update Error", error?.message);
                throw error;
            }
        }

        async DELETE(model, entitySet, filters) {
            try {
                const context = await this._findFirstContext(model, entitySet, filters);

                if (!context) {
                    this._showToast("No matching record found.");
                    return;
                }

                await context.delete();
                this._showToast("Record deleted successfully!");
            } catch (error) {
                this._showMessageBoxError("Delete Error", `Error deleting entry: ${error.message}`);
                throw error;
            }
        }

        async FETCH_POST(url, newData) {
            try {
                const response = await fetch(url, {
                    method: "POST",
                    headers: {
                        "Content-Type": "application/json"
                    },
                    body: JSON.stringify(newData)
                });
                const result = await response.json();

                if (!response.ok) {
                    this._showMessageBoxError("Request Error", `Status ${result.error.code} - ${result.error.message}`);
                    return null;
                }

                return result;
            } catch (error) {
                this._showMessageBoxError("Request Error", error.message);
                throw error;
            }
        }

        _assertListRequest(model, entitySet, skip, top) {
            if (!model || !(model instanceof sap.ui.model.odata.v4.ODataModel)) {
                throw new Error("Invalid OData V4 model.");
            }

            if (typeof entitySet !== "string" || entitySet.trim() === "") {
                throw new Error("Entity set must be a non-empty string.");
            }

            if (skip < 0 || !Number.isInteger(skip)) {
                throw new Error("Skip value must be a non-negative integer.");
            }

            if (top <= 0 || !Number.isInteger(top)) {
                throw new Error("Top value must be a positive integer.");
            }
        }

        _buildQueryOptions(select, expand) {
            const queryOptions = {};

            if (select && typeof select === "string") {
                queryOptions.$select = select.trim();
            }

            if (expand && typeof expand === "string") {
                queryOptions.$expand = expand.trim();
            }

            return queryOptions;
        }

        async _findCreatedRecord(model, entitySet, newData) {
            const filters = Object.keys(newData || {}).map(function (key) {
                return new sap.ui.model.Filter(key, sap.ui.model.FilterOperator.EQ, newData[key]);
            });
            const context = await this._findFirstContext(model, entitySet, filters);

            return context?.getObject?.() || null;
        }

        async _findFirstContext(model, entitySet, filters) {
            const listBinding = model.bindList(entitySet, undefined, undefined, filters);
            const contexts = await listBinding.requestContexts();
            return contexts[0] || null;
        }

        _showToast(message) {
            sap.m.MessageToast.show(message);
        }

        _showMessageBoxError(title, message) {
            sap.m.MessageBox.error(message || "Unexpected OData error.", {
                title,
                actions: sap.m.MessageBox.Action.CLOSE
            });
        }
    };
});