navidev-adt-api/dist/adtTransport/adtTransport.js

API de conexión al Abap Developer Tools

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const adtConnection_1 = require("../adtConnection/adtConnection");
const transportConfigurationApp_1 = __importDefault(require("./transportConfigurationApp"));
const transportObjectApp_1 = __importDefault(require("./transportObjectApp"));
const transportOperationsApp_1 = __importDefault(require("./transportOperationsApp"));
const transportReleaseApp_1 = __importDefault(require("./transportReleaseApp"));
const transportOrderApp_1 = __importDefault(require("./transportOrderApp"));
const transportValueHelpApp_1 = __importDefault(require("./transportValueHelpApp"));
const Result_1 = require("../shared/core/Result");
__exportStar(require("./transportTypes"), exports);
__exportStar(require("./transportConstants"), exports);
class AdtTransport {
    constructor(logonData) {
        this.connectionController = new adtConnection_1.AdtConnection(logonData);
        this.configurationApp = new transportConfigurationApp_1.default(this.connectionController);
        this.transportOperations = new transportOperationsApp_1.default(this.connectionController);
        this.orderApp = new transportOrderApp_1.default(this.connectionController, this.configurationApp, this.transportOperations);
        this.releaseApp = new transportReleaseApp_1.default(this.connectionController);
        this.valueHelpApp = new transportValueHelpApp_1.default(this.connectionController);
        this.transportObject = new transportObjectApp_1.default(this.connectionController);
    }
    /**
     * Devuelve las ordenes en versiones S4 donde se busca a partir de una configuración(como los
     * paramétros de la SE09/SE10) establecida (una por defecto o puede ser modificada))
     * @param target
     * @param urlConfiguration
     * @returns
     */
    getUserOrders() {
        return __awaiter(this, arguments, void 0, function* (target = true, urlConfiguration) {
            return this.orderApp.getUserOrders(target, urlConfiguration);
        });
    }
    /**
     * Obtención de las ordenes del usuario cuando no hay configuración. Es decir,
     * para versión de SAP antiguas(digo antiguas pero son 7.50/7.51. Pero anteriores a S/4 HANA)
     * @param user Usuario
     * @param target Clasifica por la capa de transporte
     * @returns
     */
    getUsersOrdersWOConf(user, target = true) {
        return this.orderApp.getUserOrdersWOConf(user, target);
    }
    /**
     * Añade un usuario a la orden
     * @param order Orden
     * @param user Usuario
     * @returns
     */
    addUserOrder(order, user) {
        return __awaiter(this, void 0, void 0, function* () {
            let resultNewTask = yield this.transportOperations.addUserOrder(order, user);
            if (resultNewTask.isSuccess) {
                let resulTaskInfo = yield this.orderApp.detailOrderTask(resultNewTask.getValue().number);
                if (resulTaskInfo.isSuccess)
                    // El detalle devuelve la orden y en el atributo "tasks" devuelve la info de la tarea pasada,
                    // que es lo que nos interesa.
                    return Result_1.Result.ok(resulTaskInfo.getValue().tasks[0]);
                else
                    return Result_1.Result.fail(resulTaskInfo.getErrorValue());
            }
            else {
                return Result_1.Result.fail(resultNewTask.getErrorValue());
            }
        });
    }
    /**
     * Borra el contenido de una orden o tarea
     * @param order Orden
     * @returns
     */
    deleteOrder(order) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.deleteOrder(order);
        });
    }
    /**
     * Liberación de una orden o tarea
     * @param order
     */
    releaseOrder(order) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.releaseApp.releaseOrder(order);
        });
    }
    /**
     * Cambio de usuario en una orden o tarea en version previas S/4
     * @param order
     * @param user
     * @returns
     */
    changeUserOrderWOConf(order, user) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.changeUserOrderWOConf(order, user);
        });
    }
    /**
     * Cambio de usuario en una orden o tarea
     * @param order
     * @param user
     * @returns
     */
    changeUserOrder(order, user) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.changeUserOrder(order, user);
        });
    }
    /**
     * Búsqueda de la URL de configuración del si
     */
    searchConfigurations() {
        return __awaiter(this, void 0, void 0, function* () {
            return this.configurationApp.searchConfigurations();
        });
    }
    /**
     * Obtiene la configuración de transporte
     * @param idConfiguration
     */
    getConfiguration(idConfiguration) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.configurationApp.getConfiguration(idConfiguration);
        });
    }
    /**
     * Modifica la configuración
     * @param idConfiguration
     * @param transportConfiguration
     * @param etag
     * @returns
     */
    setConfiguration(idConfiguration, transportConfiguration, etag) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.configurationApp.setConfiguration(idConfiguration, transportConfiguration, etag);
        });
    }
    /**
     * Obtiene los metadatos de la configuración
     * @returns
     */
    getConfigurationMetadata() {
        return __awaiter(this, void 0, void 0, function* () {
            return this.configurationApp.getConfigurationMetadata();
        });
    }
    /**
     * Ayuda para búsqueda del campo target
     * @param filterName Patron para filtar por el nombre
     * @returns
     */
    getTargetVH(filterName) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.valueHelpApp.getTarget(filterName);
        });
    }
    /**
     * Ayuda para búsqueda del campo Tipo de objeto
     * @param filterName Patron para filtar por el nombre
     * @returns
     */
    getTypeVH(filterName) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.valueHelpApp.getType(filterName);
        });
    }
    /**
     * Ayuda para búsqueda del campo CTS Project
     * @param filterName Patron para filtar por el nombre
     * @returns
     */
    getCTSProjectVH(filterName) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.valueHelpApp.getCTSProject(filterName);
        });
    }
    /**
     * Creación de una orden
     * @param description
     * @param type
     * @param owner
     * @param target
     * @param ctsProject
     * @returns
     */
    createOrder(description, type, owner, target, ctsProject) {
        return __awaiter(this, void 0, void 0, function* () {
            // Lo que devuelve SAP de la orden es un muy pobre, por lo que se busca el detalle para devolver
            // la misma info que se devuelve al leer las ordenes de los usuarios.
            let resultCreateOrder = yield this.transportOperations.createOrder(description, type, owner, target, ctsProject);
            if (resultCreateOrder.isSuccess) {
                let resulDetailOrder = yield this.orderApp.detailOrderTask(resultCreateOrder.getValue().number);
                if (resulDetailOrder.isSuccess) {
                    return Result_1.Result.ok(resulDetailOrder.getValue());
                }
                else {
                    return Result_1.Result.fail(resulDetailOrder.getErrorValue());
                }
            }
            else {
                return Result_1.Result.fail(resultCreateOrder.getErrorValue());
            }
        });
    }
    /**
     * Cambio el tipo de tarea
     * @param task
     * @param type
     * @returns
     */
    changeTaskType(task, type) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.changeTaskType(task, type);
        });
    }
    /**
     * Mover objecto de una orden/tarea a otra orden/tarea. Los datos del objeto son los que se
     * recuperán
     * @param object
     * @param order
     * @param newOrder
     * @returns
     */
    moveObject(object) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportObject.moveObject(object);
        });
    }
    /**
     * Borrado de un objeto de una orde o tarea. Los datos del objeto son los que se
     * recuperán al leer las ordenes del usuario.
     * @param object
     * @param order
     * @returns
     */
    removeObject(object) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportObject.removeObject(object);
        });
    }
    /**
     * Añade un objeto a una orden
     * @param order Orden
     * @param objectName Nombre del objeto
     * @param objectType Tipo de objeto (ejemplo: PROG, CLAS,etc)
     * @param programID Id del objeto(ejemplo:R3TR,LIMU,etc.)
     * @returns
     */
    AddObject(order, objectName, objectType, programID) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportObject.AddObject(order, objectName, objectType, programID);
        });
    }
    /**
     * Ordenar y comprimir orden/tarea
     * @param order
     * @returns
     */
    sortAndCompress(order) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.sortAndCompress(order);
        });
    }
    /**
     * Reasignar tarea a una nueva orden.
     * @param task
     * @param newOrder
     * @returns
     */
    reassignTask(task, newOrder) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.reassignTask(task, newOrder);
        });
    }
    /**
     * Detalle de una orden/tarea. La info devuelta es la misma que la que se recupera al leer las ordenes
     * de un usuario pero a nivel de orden/tarea.
     * @param orderTask
     * @param version
     * @returns
     */
    detailOrderTask(orderTask_1) {
        return __awaiter(this, arguments, void 0, function* (orderTask, version = "workingArea") {
            return this.orderApp.detailOrderTask(orderTask, version);
        });
    }
    /**
     * Bloqueo de una orden
     * @param order
     * @returns
     */
    lockOrder(order) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.lockOrder(order);
        });
    }
    /**
     * Desbloqueo de una orden
     * @param order
     * @param lockHandle
     * @returns
     */
    unlockOrder(order, lockHandle) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.transportOperations.unlockOrder(order, lockHandle);
        });
    }
    /**
     * Edición de una orden
     * @param order
     * @returns
     */
    editOrder(order, values) {
        return __awaiter(this, void 0, void 0, function* () {
            return this.orderApp.editOrder(order, values);
        });
    }
}
exports.default = AdtTransport;