| // Copyright (c) 2000-2019 Ericsson Telecom AB Telecom AB // |
| // All rights reserved. This program and the accompanying materials are made available under the // |
| // terms of the Eclipse Public License v2.0 which accompanies this distribution, and is available at // |
| // https://www.eclipse.org/org/documents/epl-2.0/EPL-2.0.html // |
| /////////////////////////////////////////////////////////////////////////////////////////////////////// |
| function DSHelpToRequest_manual() {
|
| "use strict";
|
| var PATTERN = /%Parent(\d+)%/g;
|
| var PATTERN_IDX = /%Parent(\d+)::idx%/g;
|
|
|
| var v_help;
|
| var v_fullRequest;
|
| var v_this = this;
|
|
|
| this.setHelp = function(p_help) {
|
| v_help = p_help;
|
| };
|
|
|
| this.setRequest = function(p_request) {
|
| v_fullRequest = p_request;
|
| };
|
|
|
| ///////////////////// UTILITIES, ADDING AND CREATING REQUESTS //////////////////////////////
|
|
|
| this.createEmptyRequest = function(p_pos) {
|
| var request = {
|
| "getData" : {
|
| "source" : "Source",
|
| "element" : "Element"
|
| }
|
| };
|
| requestCreated(request, p_pos);
|
| return request;
|
| };
|
|
|
| this.createRequest = function(p_helpPath, p_pos) {
|
| var request = generateGetData(p_helpPath, []);
|
| requestCreated(request, p_pos);
|
| return request;
|
| };
|
|
|
| function requestCreated(p_request, p_pos) {
|
| if (p_pos == undefined) {
|
| p_pos = v_fullRequest.length;
|
| }
|
|
|
| v_fullRequest.splice(p_pos, 0, p_request);
|
| }
|
|
|
| this.addEmptyChildRequest = function(p_requestPath, p_pos) {
|
| var childRequest = {
|
| "getData" : {
|
| "source" : "Source",
|
| "element" : "Element"
|
| }
|
| };
|
| childRequestCreated(childRequest, p_requestPath, p_pos);
|
| return childRequest;
|
| };
|
|
|
| this.addChildRequest = function(p_helpPath, p_requestPath, p_pos, p_setData) {
|
| if (!doesNotHaveGetDataOnPath(p_requestPath)) {
|
| var childRequest = generateGetData(p_helpPath, p_requestPath);
|
|
|
| if (p_setData) {
|
| childRequest.setData = childRequest.getData;
|
| childRequest.getData = undefined;
|
| addContentAndTpToSetData(childRequest.setData, getHelpDataElement(p_helpPath).dataElement.dataElement);
|
| }
|
|
|
| childRequestCreated(childRequest, p_requestPath, p_pos);
|
| return childRequest;
|
| }
|
| };
|
|
|
| function addContentAndTpToSetData(setData, helpElement) {
|
| if (helpElement.valueType == "intType") {
|
| setData.content = "0";
|
| setData.tp = 1;
|
| } else if (helpElement.valueType == "floatType") {
|
| setData.content = "0.0";
|
| setData.tp = 2;
|
| } else if (helpElement.valueType == "boolType") {
|
| setData.content = "true";
|
| setData.tp = 3;
|
| } else if (helpElement.valueType == "charstringType") {
|
| setData.content = "";
|
| setData.tp = 4;
|
| } else if (helpElement.valueType == "octetstringType") {
|
| setData.content = "";
|
| setData.tp = 5;
|
| } else if (helpElement.valueType == "hexstringType") {
|
| setData.content = "";
|
| setData.tp = 6;
|
| } else if (helpElement.valueType == "bitstringType") {
|
| setData.content = "";
|
| setData.tp = 7;
|
| } else if (helpElement.valueType == "integerlistType") {
|
| setData.content = "0";
|
| setData.tp = 8;
|
| setData.indxsInList = [0];
|
| } else if (helpElement.valueType == "floatlistType") {
|
| setData.content = "0.0";
|
| setData.tp = 9;
|
| setData.indxsInList = [0];
|
| } else if (helpElement.valueType == "charstringlistType") {
|
| setData.content = "";
|
| setData.tp = 10;
|
| setData.indxsInList = [0];
|
| } else if (helpElement.valueType == "statusLEDType") {
|
| setData.content = "[led:green]Ok";
|
| setData.tp = 11;
|
| } else {
|
| setData.content = "";
|
| setData.tp = 0;
|
| }
|
| }
|
|
|
| this.copyRequest = function(p_path) {
|
| var currentRq = v_this.getRequestFromPath(p_path);
|
| var setOrGetData = getOrSetData(currentRq);
|
| var requestToCopy = {};
|
| requestToCopy[setOrGetData] = mcopy(v_this.getRequestCopy(p_path));
|
| var position = p_path.pop();
|
| ++position;
|
| if (p_path.length != 0) {
|
| var parent = v_this.getRequestFromPath(p_path);
|
| parent = parent[getOrSetData(parent)];
|
| parent.children.splice(position, 0, requestToCopy);
|
| } else {
|
| v_fullRequest.splice(position, 0, requestToCopy);
|
| }
|
| return requestToCopy;
|
| };
|
|
|
| this.getRequestCopy = function(p_path) {
|
| var original = v_this.getRequestFromPath(p_path);
|
| original = original[getOrSetData(original)];
|
| var copy = mcopy(original);
|
| delete copy.children;
|
| return copy;
|
| };
|
|
|
| function childRequestCreated(p_childRequest, p_requestPath, p_pos) {
|
| var request = v_this.getRequestFromPath(p_requestPath);
|
| request = request[getOrSetData(request)];
|
| if (request.children == undefined) {
|
| request.children = [];
|
| }
|
|
|
| if (p_pos == undefined) {
|
| p_pos = request.children.length;
|
| }
|
|
|
| if (request.ptcname != undefined) {
|
| p_childRequest.getData.ptcname = request.ptcname;
|
| }
|
|
|
| request.children.splice(p_pos, 0, p_childRequest);
|
| }
|
|
|
| this.deleteRequest = function(p_requestPath) {
|
| var toDeleteIndex = p_requestPath.pop();
|
| var parent = this.getRequestFromPath(p_requestPath);
|
| if (parent == undefined) {
|
| v_fullRequest.splice(toDeleteIndex, 1);
|
| } else {
|
| var setOrGetData = getOrSetData(parent);
|
| parent[setOrGetData].children.splice(toDeleteIndex, 1);
|
| }
|
| };
|
|
|
| this.convertToSetData = function(p_path) {
|
| var request = this.getRequestFromPath(p_path);
|
| request.setData = request.getData;
|
| request.getData = undefined;
|
| request.setData.children = undefined;
|
| request.setData.selection = undefined;
|
| request.setData.filter = undefined;
|
| request.setData.rangeFilter = undefined;
|
| request.setData.writableInfo = undefined;
|
| request.setData.timeline = undefined;
|
| request.setData.content = "";
|
| request.setData.tp = 0;
|
| };
|
|
|
| this.convertToGetData = function(p_path) {
|
| var request = this.getRequestFromPath(p_path);
|
| request.getData = request.setData;
|
| request.setData = undefined;
|
| request.getData.content = undefined;
|
| request.getData.tp = undefined;
|
| };
|
|
|
| this.getRequest = function() {
|
| return v_fullRequest;
|
| };
|
|
|
| this.getRequestFromPath = function(p_path) {
|
| var request = v_fullRequest[p_path[0]];
|
| for (var i = 1; i < p_path.length; ++i) {
|
| request = request[getOrSetData(request)].children[p_path[i]];
|
| }
|
| return request;
|
| };
|
|
|
| function getHelpDataElement(p_helpPath) {
|
| var source = v_help.sources[p_helpPath[0]];
|
| var dataElement = source.dataElements[p_helpPath[1]];
|
| for (var i = 2; i < p_helpPath.length; ++i) {
|
| dataElement = dataElement.children[p_helpPath[i]];
|
| }
|
| return {
|
| "source" : source,
|
| "dataElement" : dataElement
|
| };
|
| }
|
|
|
| function generateGetData(p_helpPath, p_requestPath, p_filtersThatCanBeParams) {
|
| var element = getHelpDataElement(p_helpPath);
|
| var getData = {
|
| "getData" : {
|
| "source" : element.source.source,
|
| "element" : element.dataElement.dataElement.name,
|
| "params" : getParamsForRequest(p_helpPath, p_requestPath, p_filtersThatCanBeParams)
|
| }
|
| };
|
| return getData;
|
| }
|
|
|
| ///////////////////// FILTERS //////////////////////////////
|
|
|
| this.getFilterPart = function(p_requestPath, p_filterPath) {
|
| var request = v_this.getRequestFromPath(p_requestPath);
|
| var filter;
|
| if (request.getData)
|
| filter = request.getData.filter;
|
| else
|
| filter = request.setData.filter;
|
| if (p_filterPath.length == 0) {
|
| return filter;
|
| } else {
|
| var i = 0;
|
| while (i < p_filterPath.length - 1) {
|
| if (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined) {
|
| filter = filter.request.remapTo;
|
| } else {
|
| filter = filter.request.params[p_filterPath[i]].paramValue;
|
| }
|
| ++i;
|
| }
|
| if (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined) {
|
| return filter.request.remapTo;
|
| } else {
|
| return filter.request.params[p_filterPath[i]].paramValue;
|
| }
|
| }
|
| };
|
|
|
| this.getFilterPartCopy = function(p_requestPath, p_filterPath) {
|
| var filter = mcopy(v_this.getFilterPart(p_requestPath, p_filterPath));
|
| if (filter.request != undefined) {
|
| delete filter.request.params;
|
| delete filter.request.remapTo;
|
| }
|
| return filter;
|
| };
|
|
|
| function changeFilterPart(p_requestPath, p_filterPath, p_changeTo, p_paramName, p_change) {
|
| var request = v_this.getRequestFromPath(p_requestPath);
|
| var filtercontainer;
|
| if (request.getData)
|
| filtercontainer = request.getData;
|
| else
|
| filtercontainer = request.setData;
|
| if (p_filterPath.length == 0) {
|
| filtercontainer.filter = p_changeTo;
|
| } else {
|
| var filter = filtercontainer.filter;
|
| var i = 0;
|
| while (i < p_filterPath.length - 1) {
|
| if (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined) {
|
| filter = filter.request.remapTo;
|
| } else {
|
| filter = filter.request.params[p_filterPath[i]].paramValue;
|
| }
|
| ++i;
|
| }
|
| if (p_paramName == "remapTo" || (p_change && (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined))) {
|
| filter.request.remapTo = p_changeTo;
|
| } else {
|
| if (filter.request.params == undefined) {
|
| filter.request.params = [];
|
| }
|
| if (filter.request.params[p_filterPath[i]] == undefined) {
|
| filter.request.params[p_filterPath[i]] = {};
|
| }
|
| if (p_paramName != undefined) {
|
| filter.request.params[p_filterPath[i]].paramName = p_paramName;
|
| }
|
| filter.request.params[p_filterPath[i]].paramValue = p_changeTo;
|
| }
|
| }
|
| }
|
|
|
| function deleteFilterPart(p_requestPath, p_filterPath) {
|
| var request = v_this.getRequestFromPath(p_requestPath);
|
| var filtercontainer;
|
| if (request.getData)
|
| filtercontainer = request.getData;
|
| else
|
| filtercontainer = request.setData;
|
| if (p_filterPath.length == 0) {
|
| filtercontainer.filter = undefined;
|
| } else {
|
| var filter = filtercontainer.filter;
|
| var i = 0;
|
| while (i < p_filterPath.length - 1) {
|
| if (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined) {
|
| filter = filter.request.remapTo;
|
| } else {
|
| filter = filter.request.params[p_filterPath[i]].paramValue;
|
| }
|
| ++i;
|
| }
|
| if (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined) {
|
| filter.request.remapTo = undefined;
|
| } else {
|
| filter.request.params.splice(p_filterPath[i], 1);
|
| }
|
| }
|
| }
|
|
|
| this.addFilterPart = function(p_requestPath, p_filterPath, p_paramName) {
|
| changeFilterPart(p_requestPath, p_filterPath, {"dataValue": "true"}, p_paramName, false);
|
| };
|
|
|
| this.deleteFilterPart = function(p_requestPath, p_filterPath) {
|
| deleteFilterPart(p_requestPath, p_filterPath);
|
| };
|
|
|
| this.changeParamNameOfFilterRequest = function(p_requestPath, p_filterPath, p_paramName) {
|
| var changeTo = v_this.getFilterPart(p_requestPath, p_filterPath);
|
| changeFilterPart(p_requestPath, p_filterPath, changeTo, p_paramName, true);
|
| };
|
|
|
| this.convertFilterPartToRequest = function(p_requestPath, p_filterPath, p_helpPath) {
|
| var filterRequest = generateGetData(p_helpPath, p_requestPath, getFiltersThatCanParams(p_requestPath, p_filterPath)).getData;
|
| if (filterRequest.params != undefined) {
|
| for (var i = 0; i < filterRequest.params.length; ++i) {
|
| filterRequest.params[i].paramValue = {"dataValue": filterRequest.params[i].paramValue};
|
| }
|
| }
|
|
|
| changeFilterPart(p_requestPath, p_filterPath, {"request": filterRequest}, undefined, true);
|
| };
|
|
|
| this.convertFilterPartToDataValue = function(p_requestPath, p_filterPath, p_newValue) {
|
| changeFilterPart(p_requestPath, p_filterPath, {"dataValue": p_newValue}, undefined, true);
|
| };
|
|
|
| function getFiltersThatCanParams(p_requestPath, p_filterPath) {
|
| var filters = [];
|
| var filterrq = v_this.getRequestFromPath(p_requestPath);
|
| var filter = filterrq[getOrSetData(filterrq)].filter;
|
| if (p_filterPath.length > 0) {
|
| for (var i = 0; i < p_filterPath.length - 1; ++i) {
|
| if (filter.request.params == undefined || filter.request.params[p_filterPath[i]] == undefined) {
|
| filters.push({'getData': filter.request});
|
| filter = filter.request.remapTo;
|
| } else {
|
| filters.push(undefined);
|
| filter = filter.request.params[p_filterPath[i]].paramValue;
|
| }
|
| }
|
| }
|
| return filters;
|
| }
|
|
|
| this.isValidToConvertFilterToRequest = function(p_requestPath, p_filterPath, p_helpPath) {
|
| return p_helpPath.length > 1 && v_this.getFilterPart(p_requestPath, p_filterPath).request == undefined && checkIfAllReferencesFound(getParamsForRequest(p_helpPath, p_requestPath, getFiltersThatCanParams(p_requestPath, p_filterPath)));
|
| };
|
|
|
| this.isValidToAddParamToFilterRequest = function(p_requestPath, p_filterPath) {
|
| var filterPathCopy = mcopy(p_filterPath);
|
| filterPathCopy.pop();
|
| if (v_this.getFilterPart(p_requestPath, filterPathCopy).request != undefined) {
|
| return true;
|
| } else {
|
| return false;
|
| }
|
| };
|
|
|
| ///////////////////// VALIDATION AND PARAMETER SEARCHING //////////////////////////////
|
|
|
| function doesNotHaveGetDataOnPath(p_requestPath) {
|
| if (p_requestPath.length == 0) {
|
| return false;
|
| }
|
| var request = v_fullRequest[p_requestPath[0]];
|
| if (request.getData == undefined) {
|
| return true;
|
| }
|
| for (var i = 1; i < p_requestPath.length; ++i) {
|
| request = request.getData.children[p_requestPath[i]];
|
| if (request.getData == undefined) {
|
| return true;
|
| }
|
| }
|
| return false;
|
| }
|
|
|
| this.isValidToAddRequest = function(p_helpPath, p_requestPath) {
|
| if (p_helpPath.length < 2 || p_requestPath.length === 0 || doesNotHaveGetDataOnPath(p_requestPath)) {
|
| return false;
|
| } else {
|
| return checkIfAllReferencesFound(getParamsForRequest(p_helpPath, p_requestPath));
|
| }
|
| };
|
|
|
| this.isValidToCreateRequest = function(p_helpPath) {
|
| if (p_helpPath.length < 2) {
|
| return false;
|
| } else {
|
| var helpParams = getHelpParamsFromPath(p_helpPath);
|
| if (helpParams == undefined || helpParams.length === 0) {
|
| return true;
|
| } else {
|
| var requestParams = createParamSkeleton(helpParams);
|
| return checkIfAllReferencesFound(requestParams);
|
| }
|
| }
|
| };
|
|
|
| function getParamsForRequest(p_helpPath, p_requestPath, p_filtersThatCanBeParams) {
|
| var helpParams = getHelpParamsFromPath(p_helpPath);
|
| if (helpParams == undefined || helpParams.length === 0) {
|
| return undefined;
|
| }
|
|
|
| var requestParams = createParamSkeleton(helpParams);
|
| if (checkIfAllReferencesFound(requestParams)) {
|
| return requestParams;
|
| }
|
|
|
| tarverseHelpBranch(p_helpPath, p_requestPath, requestParams, helpParams, p_filtersThatCanBeParams);
|
| if (checkIfAllReferencesFound(requestParams)) {
|
| return requestParams;
|
| }
|
|
|
| for (var i = 0; i < v_help.sources.length; ++i) {
|
| traverseFullHelp(v_help.sources[i].dataElements, p_requestPath, requestParams, helpParams, p_filtersThatCanBeParams);
|
| if (checkIfAllReferencesFound(requestParams)) {
|
| return requestParams;
|
| }
|
| }
|
|
|
| return requestParams;
|
| }
|
|
|
| function getHelpParamsFromPath(p_helpPath) {
|
| var element = getHelpDataElement(p_helpPath);
|
| return element.dataElement.dataElement.parameters;
|
| }
|
|
|
| function checkIfAllReferencesFound(p_requestParams) {
|
| if (p_requestParams == undefined) {
|
| return true;
|
| }
|
| for (var i = 0; i < p_requestParams.length; ++i) {
|
| if (p_requestParams[i].paramValue == undefined) {
|
| return false;
|
| }
|
| }
|
| return true;
|
| }
|
|
|
| function createParamSkeleton(p_helpParams) {
|
| var paramList = [];
|
| for (var i = 0; i < p_helpParams.length; ++i) {
|
| var paramName = p_helpParams[i].name;
|
| var paramValue;
|
| if (p_helpParams[i].typeDescriptor != undefined && p_helpParams[i].typeDescriptor.reference != undefined) {
|
| paramList.push({
|
| "paramName" : paramName
|
| });
|
| } else if (p_helpParams[i].exampleValue != undefined) {
|
| paramList.push({
|
| "paramName" : paramName,
|
| "paramValue" : p_helpParams[i].exampleValue
|
| });
|
| } else {
|
| paramList.push({
|
| "paramName" : paramName,
|
| "paramValue" : ""
|
| });
|
| }
|
| }
|
| return paramList;
|
| }
|
|
|
| function tarverseHelpBranch(p_helpPath, p_requestPath, p_requestParams, p_helpParams, p_filtersThatCanBeParams) {
|
| var source = v_help.sources[p_helpPath[0]];
|
| var dataElement = source.dataElements[p_helpPath[1]];
|
| checkDataElementInParams(dataElement, p_requestPath, p_requestParams, p_helpParams, p_filtersThatCanBeParams);
|
|
|
| for (var i = 2; i < p_helpPath.length; ++i) {
|
| dataElement = dataElement.children[p_helpPath[i]];
|
| checkDataElementInParams(dataElement, p_requestPath, p_requestParams, p_helpParams, p_filtersThatCanBeParams);
|
| }
|
| }
|
|
|
| function traverseFullHelp(p_dataElementList, p_requestPath, p_requestParams, p_helpParams, p_filtersThatCanBeParams) {
|
| for (var i = 0; i < p_dataElementList.length; ++i) {
|
| var dataElement = p_dataElementList[i];
|
| checkDataElementInParams(dataElement, p_requestPath, p_requestParams, p_helpParams, p_filtersThatCanBeParams);
|
| if (p_dataElementList[i].children != undefined) {
|
| traverseFullHelp(p_dataElementList[i].children, p_requestPath, p_requestParams, p_helpParams);
|
| }
|
| }
|
| }
|
|
|
| function checkDataElementInParams(p_dataElement, p_requestPath, p_requestParams, p_helpParams, p_filtersThatCanBeParams) {
|
| for (var i = 0; i < p_requestParams.length; ++i) {
|
| if (p_requestParams[i].paramValue == undefined && p_dataElement.dataElement.typeDescriptor != undefined && p_dataElement.dataElement.typeDescriptor.typeName === p_helpParams[i].typeDescriptor.reference.typeName) {
|
| checkDataElementOnRequestPath(p_dataElement, p_requestPath, p_requestParams[i], p_filtersThatCanBeParams);
|
| }
|
| }
|
| }
|
|
|
| function checkDataElementOnRequestPath(p_dataElement, p_requestPath, p_param, p_filtersThatCanBeParams) {
|
| var request = v_fullRequest[p_requestPath[0]];
|
| if (request == undefined) {
|
| return;
|
| }
|
| if (checkDataCorrespondance(p_dataElement, request)) {
|
| p_param.paramValue = "%Parent0%";
|
| }
|
| for (var i = 1; i < p_requestPath.length; ++i) {
|
| if (request.getData)
|
| request = request.getData.children[p_requestPath[i]];
|
| else if (request.setData)
|
| request = request.setData.children[p_requestPath[i]];
|
| if (checkDataCorrespondance(p_dataElement, request)) {
|
| p_param.paramValue = "%Parent" + i +"%";
|
| return;
|
| }
|
| }
|
| if (p_filtersThatCanBeParams != undefined) {
|
| for (var i = 0; i < p_filtersThatCanBeParams.length; ++i) {
|
| request = p_filtersThatCanBeParams[i];
|
| if (request != undefined && checkDataCorrespondance(p_dataElement, request)) {
|
| p_param.paramValue = "%FilterParent" + i +"%";
|
| return;
|
| }
|
| }
|
| }
|
| }
|
|
|
| /**
|
| Check if actual request equals actual help dataelement, which is true if their name is equal and they have the same parameters.
|
| */
|
| function checkDataCorrespondance(p_dataElement, p_request) {
|
| var setOrGetData = getOrSetData(p_request);
|
| var ok = p_dataElement.dataElement.name === p_request[setOrGetData].element;
|
| if (p_dataElement.dataElement.parameters == undefined || p_dataElement.dataElement.parameters.length === 0) {
|
| return ok && (p_request[setOrGetData].params == undefined || p_request[setOrGetData].params.length === 0);
|
| }
|
| for (var i = 0; i < p_dataElement.dataElement.parameters.length && ok; ++i) {
|
| var helpParam = p_dataElement.dataElement.parameters[i];
|
| ok = ok && p_request[setOrGetData].params != undefined && p_request[setOrGetData].params[i] != undefined && helpParam.name === p_request[setOrGetData].params[i].paramName;
|
| }
|
| return ok;
|
| }
|
|
|
| ///////////////////// MOVING REQUEST IN THE TREE //////////////////////////////
|
|
|
| this.isValidToMoveRequest = function(p_fromPath, p_toPath) {
|
| var fromRequest = v_this.getRequestFromPath(p_fromPath);
|
|
|
| var fromParentPath = mcopy(p_fromPath);
|
| fromParentPath.pop();
|
|
|
| if (hasPrefix(p_toPath, fromParentPath)) {
|
| return true;
|
| } else if (hasPrefix(p_fromPath, p_toPath)) {
|
| var allowedParentsLessThan = p_toPath.length;
|
| var currentDepth = p_fromPath.length - 1;
|
| return checkAllowedParents(fromRequest, allowedParentsLessThan, currentDepth);
|
| } else {
|
| return false;
|
| }
|
| };
|
|
|
| function findMaxParent(str) {
|
| var pattern = new RegExp(PATTERN);
|
| var max = 0;
|
| var match = pattern.exec(str);
|
| if (match == undefined) {
|
| return undefined;
|
| }
|
| while (match != undefined) {
|
| if (match[1] > 0 && match[1] > max) {
|
| max = match[1];
|
| }
|
| match = pattern.exec(str);
|
| }
|
| return max;
|
| }
|
|
|
| function checkAllowedParents(request, allowedParentsLessThan, currentDepth) {
|
| var str = JSON.stringify(request);
|
| var maxparent = findMaxParent(str);
|
| if (maxparent != undefined && maxparent >= allowedParentsLessThan && maxparent < currentDepth) {
|
| return false;
|
| } else {
|
| return true
|
| }
|
| }
|
|
|
| function getOrSetData(request) {
|
| var setOrGetData = "getData";
|
| if (request && request.setData)
|
| setOrGetData = "setData";
|
| return setOrGetData;
|
| }
|
| this.moveRequest = function(p_fromPath, p_toPath, p_position) {
|
| var futureSiblingList;
|
| if (p_toPath.length == 0) {
|
| futureSiblingList = v_fullRequest;
|
| } else {
|
| var toParent = v_this.getRequestFromPath(p_toPath);
|
| toParent = toParent[getOrSetData(toParent)];
|
| if (toParent.children == undefined) {
|
| toParent.children = [];
|
| }
|
| futureSiblingList = toParent.children;
|
| }
|
|
|
| var request;
|
| var fromParentPath = mcopy(p_fromPath);
|
| var fromId = fromParentPath.pop();
|
| if (fromParentPath.length == 0) {
|
| request = v_fullRequest.splice(fromId, 1)[0];
|
| } else {
|
| var fromParent = v_this.getRequestFromPath(fromParentPath);
|
| fromParent = fromParent[getOrSetData(fromParent)];
|
| request = fromParent.children.splice(fromId, 1)[0];
|
| if (fromParent.children.length == 0 && fromParent.children != futureSiblingList) {
|
| fromParent.children = undefined;
|
| }
|
| }
|
|
|
| if (p_position > fromId && p_toPath.length === p_fromPath.length -1) {
|
| --p_position;
|
| }
|
| futureSiblingList.splice(p_position, 0, request);
|
|
|
| var fromDepth = p_fromPath.length - 1;
|
| var changeBy = p_toPath.length - (p_fromPath.length - 1);
|
| updateRequestParams(request, fromDepth, changeBy);
|
| };
|
|
|
| function incrementBy(str, fromDepth, amount, regex, suffix) {
|
| var pattern = new RegExp(regex);
|
| var match = pattern.exec(str);
|
| var radix = 10;
|
| var parentid = parseInt(match[1], radix);
|
| if (parentid >= fromDepth) {
|
| return "%Parent" + (parseInt(match[1], radix) + amount) + suffix + "%";
|
| } else {
|
| return str;
|
| }
|
| }
|
|
|
| function incrementParentBy(str, fromDepth, amount) {
|
| return incrementBy(str, fromDepth, amount, PATTERN, "");
|
| }
|
|
|
| function incrementParentIndexBy(str, fromDepth, amount) {
|
| return incrementBy(str, fromDepth, amount, PATTERN_IDX, "::idx");
|
| }
|
|
|
| function updateRequestParams(request, fromDepth, changeBy) {
|
| var setOrGetData = getOrSetData(request);
|
| var string = JSON.stringify(request[setOrGetData]);
|
| string = string.replace(new RegExp(PATTERN_IDX), function(match) {return incrementParentIndexBy(match, fromDepth, changeBy);});
|
| string = string.replace(new RegExp(PATTERN), function(match) {return incrementParentBy(match, fromDepth, changeBy);});
|
| request[setOrGetData] = JSON.parse(string);
|
| }
|
| }
|
