diff --git a/components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/LifecycleStateManger.java b/components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/LifecycleStateManger.java index ac011a9401..86f4381e40 100644 --- a/components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/LifecycleStateManger.java +++ b/components/application-mgt/org.wso2.carbon.device.application.mgt.core/src/main/java/org/wso2/carbon/device/application/mgt/core/lifecycle/LifecycleStateManger.java @@ -3,11 +3,9 @@ package org.wso2.carbon.device.application.mgt.core.lifecycle; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.wso2.carbon.device.application.mgt.common.exception.LifecycleManagementException; +import org.wso2.carbon.device.application.mgt.core.internal.DataHolder; import org.wso2.carbon.device.application.mgt.core.lifecycle.config.LifecycleState; -import org.wso2.carbon.device.application.mgt.core.util.APIUtil; -import org.wso2.carbon.device.mgt.common.permission.mgt.Permission; import org.wso2.carbon.device.mgt.common.permission.mgt.PermissionManagementException; -import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder; import org.wso2.carbon.device.mgt.core.permission.mgt.PermissionUtils; import org.wso2.carbon.device.mgt.core.search.mgt.Constants; import org.wso2.carbon.user.api.UserRealm; @@ -59,7 +57,7 @@ public class LifecycleStateManger { String permission = getPermissionForStateChange(nextState); if(permission != null) { try { - userRealm = DeviceManagementDataHolder.getInstance().getRealmService().getTenantUserRealm(tenantId); + userRealm = DataHolder.getInstance().getRealmService().getTenantUserRealm(tenantId); if (userRealm != null && userRealm.getAuthorizationManager() != null && userRealm.getAuthorizationManager().isUserAuthorized(username, PermissionUtils.getAbsolutePermissionPath(permission), diff --git a/node_modules/regjsgen/LICENSE b/node_modules/regjsgen/LICENSE new file mode 100644 index 0000000000..907cb2ea33 --- /dev/null +++ b/node_modules/regjsgen/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright 2014-2018 Benjamin Tan + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/node_modules/regjsgen/README.md b/node_modules/regjsgen/README.md new file mode 100644 index 0000000000..74dc3e9946 --- /dev/null +++ b/node_modules/regjsgen/README.md @@ -0,0 +1,33 @@ +# regjsgen [![Build status](https://travis-ci.org/bnjmnt4n/regjsgen.svg?branch=master)](https://travis-ci.org/bnjmnt4n/regjsgen) [![Code coverage status](https://codecov.io/gh/bnjmnt4n/regjsgen/branch/master/graph/badge.svg)](https://codecov.io/gh/bnjmnt4n/regjsgen) + +Generate regular expressions from [regjsparser](https://github.com/jviereck/regjsparser)’s AST. + +## Installation + +```bash +npm install --save regjsgen +``` + +## API + +### `regjsgen.generate(ast)` + +This function accepts an abstract syntax tree representing a regular expression, and returns the generated regular expression string. + +```js +var regjsparser = require('regjsparser'); +var regjsgen = require('regjsgen'); + +// Generate an AST with `regjsparser`. +var ast = regjsparser.parse(regex); + +// Modify AST +// … + +// Generate `RegExp` string with `regjsgen`. +regex = regjsgen.generate(ast); +``` + +## Support + +Tested in Node.js 0.10, 0.12, 4, 6 and 8. diff --git a/node_modules/regjsgen/package.json b/node_modules/regjsgen/package.json new file mode 100644 index 0000000000..4d0799711b --- /dev/null +++ b/node_modules/regjsgen/package.json @@ -0,0 +1,95 @@ +{ + "_args": [ + [ + "regjsgen", + "/media/gathika/MainDisk/entgra_repos/carbon-device-mgt" + ] + ], + "_from": "regjsgen@latest", + "_hasShrinkwrap": false, + "_id": "regjsgen@0.5.0", + "_inCache": true, + "_installable": true, + "_location": "/regjsgen", + "_nodeVersion": "8.9.3", + "_npmOperationalInternal": { + "host": "s3://npm-registry-packages", + "tmp": "tmp/regjsgen_0.5.0_1540608114803_0.0388782175432143" + }, + "_npmUser": { + "email": "demoneaux@gmail.com", + "name": "d10" + }, + "_npmVersion": "5.5.1", + "_phantomChildren": {}, + "_requested": { + "name": "regjsgen", + "raw": "regjsgen", + "rawSpec": "", + "scope": null, + "spec": "latest", + "type": "tag" + }, + "_requiredBy": [ + "/" + ], + "_resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.0.tgz", + "_shasum": "a7634dc08f89209c2049adda3525711fb97265dd", + "_shrinkwrap": null, + "_spec": "regjsgen", + "_where": "/media/gathika/MainDisk/entgra_repos/carbon-device-mgt", + "author": { + "name": "Benjamin Tan", + "url": "https://bnjmnt4n.now.sh/" + }, + "bugs": { + "url": "https://github.com/bnjmnt4n/regjsgen/issues" + }, + "dependencies": {}, + "description": "Generate regular expressions from regjsparser’s AST.", + "devDependencies": { + "codecov": "^3.1.0", + "istanbul": "~0.4.5", + "regjsparser": "~0.4.0", + "request": "^2.88.0" + }, + "directories": {}, + "dist": { + "fileCount": 4, + "integrity": "sha512-RnIrLhrXCX5ow/E5/Mh2O4e/oa1/jW0eaBKTSy3LaCj+M3Bqvm97GWDp2yUtzIs4LEn65zR2yiYGFqb2ApnzDA==", + "npm-signature": "-----BEGIN PGP SIGNATURE-----\r\nVersion: OpenPGP.js v3.0.4\r\nComment: https://openpgpjs.org\r\n\r\nwsFcBAEBCAAQBQJb09BzCRA9TVsSAnZWagAAHL8P/2+qPfMU6ChUdXtesJcS\nb4J4OtV52K6iYdJky/TSI2udBPTtzyJ3JXIr5Q2RnBj3wIkDuhFGesCoZ7Ap\noUEm8jYnQXTV1PBt3Q1nTeUww0Wcj7/0T6PHVA1IuKHxt56yP5/h+C9eTbK+\nFabsdn86iXKZnUNggtiVAjE0JarqVfKZC9rpvrTdTFn9hx+rr02RPtXHHb1J\nHipRJsJ6zsLRyZ1ysIB3VZYrIya2SH1FjiddvVbLbB7QDnnlYKuzC7n4p4uB\nVcTWQMIBg3fkqjYIDvx765FABBqxaMxYdjiUsQK/mLz+uilKukbHWhKuGsAb\n/F47dJAUKxs6yXreiQsLNNhAUcWQbE7cDmNKfTI9sMSjtctogTqYWgJb0PVi\na0CbWNclNF7mFwxTsanjCFypZZSMgpTsxuJDf4UrjZvfsBYfqtH7HhpIVsZq\nBFBev4QpQkaK8SOm1R8QCFy1fiMqlEREU7goErBO6kQvQC9DiEq7h9pRwVnV\nhe2pr1OyMcsSkADI4EjvwrUgoirbZzpZ/5ir2LUyQ+QodIgPc6DhDEbldlI1\nmr0lFWHkcmFbo4TPcz/sDUS4SSVvrxiQ2J/XuH9s61YJltnwWhFFauRUdI22\nalBB6AE1zPw2kP580z7JLsEWyMPYELCKmcpXSRdq58NCMZXvrzbqjN/+6dBS\n1XD3\r\n=h56Q\r\n-----END PGP SIGNATURE-----\r\n", + "shasum": "a7634dc08f89209c2049adda3525711fb97265dd", + "tarball": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.0.tgz", + "unpackedSize": 13630 + }, + "gitHead": "3e898bdd4577e5f6fc9ffc7c867bbe8661b28344", + "homepage": "https://github.com/bnjmnt4n/regjsgen", + "keywords": [ + "ast", + "generate", + "regex", + "regexp", + "regular expressions" + ], + "license": "MIT", + "main": "regjsgen.js", + "maintainers": [ + { + "name": "d10", + "email": "demoneaux@gmail.com" + } + ], + "name": "regjsgen", + "optionalDependencies": {}, + "readme": "ERROR: No README data found!", + "repository": { + "type": "git", + "url": "git+https://github.com/bnjmnt4n/regjsgen.git" + }, + "scripts": { + "coverage": "istanbul cover --report html tests/tests.js", + "test": "node tests/tests.js", + "update-fixtures": "node tests/update-fixtures.js" + }, + "version": "0.5.0" +} diff --git a/node_modules/regjsgen/regjsgen.js b/node_modules/regjsgen/regjsgen.js new file mode 100644 index 0000000000..80ef1964f7 --- /dev/null +++ b/node_modules/regjsgen/regjsgen.js @@ -0,0 +1,401 @@ +/*! + * regjsgen 0.5.0 + * Copyright 2014-2018 Benjamin Tan + * Available under MIT license + */ +;(function() { + 'use strict'; + + // Used to determine if values are of the language type `Object`. + var objectTypes = { + 'function': true, + 'object': true + }; + + // Used as a reference to the global object. + var root = (objectTypes[typeof window] && window) || this; + + // Detect free variable `exports`. + var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports; + + // Detect free variable `module`. + var hasFreeModule = objectTypes[typeof module] && module && !module.nodeType; + + // Detect free variable `global` from Node.js or Browserified code and use it as `root`. + var freeGlobal = freeExports && hasFreeModule && typeof global == 'object' && global; + if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) { + root = freeGlobal; + } + + // Used to check objects for own properties. + var hasOwnProperty = Object.prototype.hasOwnProperty; + + /*--------------------------------------------------------------------------*/ + + // Generates a string based on the given code point. + // Based on https://mths.be/fromcodepoint by @mathias. + function fromCodePoint() { + var codePoint = Number(arguments[0]); + + if ( + !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` + codePoint < 0 || // not a valid Unicode code point + codePoint > 0x10FFFF || // not a valid Unicode code point + Math.floor(codePoint) != codePoint // not an integer + ) { + throw RangeError('Invalid code point: ' + codePoint); + } + + if (codePoint <= 0xFFFF) { + // BMP code point + return String.fromCharCode(codePoint); + } else { + // Astral code point; split in surrogate halves + // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae + codePoint -= 0x10000; + var highSurrogate = (codePoint >> 10) + 0xD800; + var lowSurrogate = (codePoint % 0x400) + 0xDC00; + return String.fromCharCode(highSurrogate, lowSurrogate); + } + } + + /*--------------------------------------------------------------------------*/ + + // Ensures that nodes have the correct types. + var assertTypeRegexMap = {}; + function assertType(type, expected) { + if (expected.indexOf('|') == -1) { + if (type == expected) { + return; + } + + throw Error('Invalid node type: ' + type + '; expected type: ' + expected); + } + + expected = hasOwnProperty.call(assertTypeRegexMap, expected) + ? assertTypeRegexMap[expected] + : (assertTypeRegexMap[expected] = RegExp('^(?:' + expected + ')$')); + + if (expected.test(type)) { + return; + } + + throw Error('Invalid node type: ' + type + '; expected types: ' + expected); + } + + /*--------------------------------------------------------------------------*/ + + // Generates a regular expression string based on an AST. + function generate(node) { + var type = node.type; + + if (hasOwnProperty.call(generators, type)) { + return generators[type](node); + } + + throw Error('Invalid node type: ' + type); + } + + /*--------------------------------------------------------------------------*/ + + function generateAlternative(node) { + assertType(node.type, 'alternative'); + + var terms = node.body, + i = -1, + length = terms.length, + result = ''; + + while (++i < length) { + result += generateTerm(terms[i]); + } + + return result; + } + + function generateAnchor(node) { + assertType(node.type, 'anchor'); + + switch (node.kind) { + case 'start': + return '^'; + case 'end': + return '$'; + case 'boundary': + return '\\b'; + case 'not-boundary': + return '\\B'; + default: + throw Error('Invalid assertion'); + } + } + + function generateAtom(node) { + assertType(node.type, 'anchor|characterClass|characterClassEscape|dot|group|reference|value'); + + return generate(node); + } + + function generateCharacterClass(node) { + assertType(node.type, 'characterClass'); + + var classRanges = node.body, + i = -1, + length = classRanges.length, + result = ''; + + if (node.negative) { + result += '^'; + } + + while (++i < length) { + result += generateClassAtom(classRanges[i]); + } + + return '[' + result + ']'; + } + + function generateCharacterClassEscape(node) { + assertType(node.type, 'characterClassEscape'); + + return '\\' + node.value; + } + + function generateUnicodePropertyEscape(node) { + assertType(node.type, 'unicodePropertyEscape'); + + return '\\' + (node.negative ? 'P' : 'p') + '{' + node.value + '}'; + } + + function generateCharacterClassRange(node) { + assertType(node.type, 'characterClassRange'); + + var min = node.min, + max = node.max; + + if (min.type == 'characterClassRange' || max.type == 'characterClassRange') { + throw Error('Invalid character class range'); + } + + return generateClassAtom(min) + '-' + generateClassAtom(max); + } + + function generateClassAtom(node) { + assertType(node.type, 'anchor|characterClassEscape|characterClassRange|dot|value'); + + return generate(node); + } + + function generateDisjunction(node) { + assertType(node.type, 'disjunction'); + + var body = node.body, + i = -1, + length = body.length, + result = ''; + + while (++i < length) { + if (i != 0) { + result += '|'; + } + result += generate(body[i]); + } + + return result; + } + + function generateDot(node) { + assertType(node.type, 'dot'); + + return '.'; + } + + function generateGroup(node) { + assertType(node.type, 'group'); + + var result = ''; + + switch (node.behavior) { + case 'normal': + if (node.name) { + result += '?<' + generateIdentifier(node.name) + '>'; + } + break; + case 'ignore': + result += '?:'; + break; + case 'lookahead': + result += '?='; + break; + case 'negativeLookahead': + result += '?!'; + break; + case 'lookbehind': + result += '?<='; + break; + case 'negativeLookbehind': + result += '?'; + } + + throw new Error('Unknown reference type'); + } + + function generateTerm(node) { + assertType(node.type, 'anchor|characterClass|characterClassEscape|empty|group|quantifier|reference|unicodePropertyEscape|value'); + + return generate(node); + } + + function generateValue(node) { + assertType(node.type, 'value'); + + var kind = node.kind, + codePoint = node.codePoint; + + if (typeof codePoint != 'number') { + throw new Error('Invalid code point: ' + codePoint); + } + + switch (kind) { + case 'controlLetter': + return '\\c' + fromCodePoint(codePoint + 64); + case 'hexadecimalEscape': + return '\\x' + ('00' + codePoint.toString(16).toUpperCase()).slice(-2); + case 'identifier': + return '\\' + fromCodePoint(codePoint); + case 'null': + return '\\' + codePoint; + case 'octal': + return '\\' + codePoint.toString(8); + case 'singleEscape': + switch (codePoint) { + case 0x0008: + return '\\b'; + case 0x0009: + return '\\t'; + case 0x000A: + return '\\n'; + case 0x000B: + return '\\v'; + case 0x000C: + return '\\f'; + case 0x000D: + return '\\r'; + default: + throw Error('Invalid code point: ' + codePoint); + } + case 'symbol': + return fromCodePoint(codePoint); + case 'unicodeEscape': + return '\\u' + ('0000' + codePoint.toString(16).toUpperCase()).slice(-4); + case 'unicodeCodePointEscape': + return '\\u{' + codePoint.toString(16).toUpperCase() + '}'; + default: + throw Error('Unsupported node kind: ' + kind); + } + } + + /*--------------------------------------------------------------------------*/ + + // Used to generate strings for each node type. + var generators = { + 'alternative': generateAlternative, + 'anchor': generateAnchor, + 'characterClass': generateCharacterClass, + 'characterClassEscape': generateCharacterClassEscape, + 'characterClassRange': generateCharacterClassRange, + 'unicodePropertyEscape': generateUnicodePropertyEscape, + 'disjunction': generateDisjunction, + 'dot': generateDot, + 'group': generateGroup, + 'quantifier': generateQuantifier, + 'reference': generateReference, + 'value': generateValue + }; + + /*--------------------------------------------------------------------------*/ + + // Export regjsgen. + var regjsgen = { + 'generate': generate + }; + + // Some AMD build optimizers, like r.js, check for condition patterns like the following: + if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { + // Define as an anonymous module so it can be aliased through path mapping. + define(function() { + return regjsgen; + }); + + root.regjsgen = regjsgen; + } + // Check for `exports` after `define` in case a build optimizer adds an `exports` object. + else if (freeExports && hasFreeModule) { + // Export for CommonJS support. + freeExports.generate = generate; + } + else { + // Export to the global object. + root.regjsgen = regjsgen; + } +}.call(this));