Returns information for a specific path id

@param pathId ID of path
@param clientUUID client UUID
@param filters filters to set on endpoint
@return EndpointOverride
@throws Exception exception
339460
public EndpointOverride getPath(int pathId, String clientUUID, String[] filters) throws Exception {
        EndpointOverride endpoint = null;
        PreparedStatement statement = null;
        ResultSet results = null;

        try (Connection sqlConnection = sqlService.getConnection()) {
            String queryString = this.getPathSelectString();
            queryString += " AND " + Constants.DB_TABLE_PATH + "." + Constants.GENERIC_ID + "=" + pathId + ";";
            statement = sqlConnection.prepareStatement(queryString);
            statement.setString(1, clientUUID);

            results = statement.executeQuery();

            if (results.next()) {
                endpoint = this.getEndpointOverrideFromResultSet(results);
                endpoint.setFilters(filters);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if (results != null) {
                    results.close();
                }
            } catch (Exception e) {
            }
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }

        return endpoint;
    }
461422
public static long count_filtered(nitro_service service, String id, String filter) throws Exception{
		linkset_channel_binding obj = new linkset_channel_binding();
		obj.set_id(id);
		options option = new options();
		option.set_count(true);
		option.set_filter(filter);
		linkset_channel_binding[] response = (linkset_channel_binding[]) obj.getfiltered(service, option);
		if (response != null) {
			return response[0].__count;
		}
		return 0;
	}
687983
public static Application get(final BandwidthClient client, final String id) throws Exception {
        assert(id != null);
        final String applicationUri = client.getUserResourceInstanceUri(BandwidthConstants.APPLICATIONS_URI_PATH, id);
        final JSONObject applicationObj = toJSONObject( client.get(applicationUri, null) );
        
        final Application application = new Application(client, applicationObj);
        return application;
    }
457376
public static PathFilter getInputPathFilter(JobContext context) {
    Configuration conf = context.getConfiguration();
    Class<?> filterClass = conf.getClass("mapred.input.pathFilter.class", null,
        PathFilter.class);
    return (filterClass != null) ?
        (PathFilter) ReflectionUtils.newInstance(filterClass, conf) : null;
  }
1260096
public static policymap[] get_filtered(nitro_service service, String filter) throws Exception{
		policymap obj = new policymap();
		options option = new options();
		option.set_filter(filter);
		policymap[] response = (policymap[]) obj.getfiltered(service, option);
		return response;
	}
591587
public static List<Path> getSubDirectoryPathList(Path startDirectoryPath,
			Predicate<Path> filter) {
		return getSubPathList(startDirectoryPath, Integer.MAX_VALUE,
				DirectoryAndNotSymbolicLinkFilter.and(filter));
	}
423422
public static streamidentifier[] get_filtered(nitro_service service, filtervalue[] filter) throws Exception{
		streamidentifier obj = new streamidentifier();
		options option = new options();
		option.set_filter(filter);
		streamidentifier[] response = (streamidentifier[]) obj.getfiltered(service, option);
		return response;
	}
1314279
public static location[] get_filtered(nitro_service service, filtervalue[] filter) throws Exception{
		location obj = new location();
		options option = new options();
		option.set_filter(filter);
		location[] response = (location[]) obj.getfiltered(service, option);
		return response;
	}
750271
function getIdsFromPayload(payload, conf, path) {
    return payload.map(function (payloadPiece) { return getId(payloadPiece, conf, path, payload); });
}
360522
public static HashMap<String, String> getUrlVariables(final Filter filter) {
        final HashMap<String, String> vars = new HashMap<String, String>();

        for (final FilterTag filterTag : filter.getFilterTags()) {
            final Tag tag = filterTag.getTag();
            final Integer tagState = filterTag.getTagState();

            if (tagState == CommonFilterConstants.MATCH_TAG_STATE) {
                vars.put(CommonFilterConstants.MATCH_TAG + tag.getTagId(), CommonFilterConstants.MATCH_TAG_STATE + "");
            } else if (tagState == CommonFilterConstants.NOT_MATCH_TAG_STATE) {
                vars.put(CommonFilterConstants.MATCH_TAG + tag.getTagId(), CommonFilterConstants.NOT_MATCH_TAG_STATE + "");
            } else if (tagState == CommonFilterConstants.GROUP_TAG_STATE) {
                vars.put(CommonFilterConstants.GROUP_TAG + tag.getTagId(), CommonFilterConstants.GROUP_TAG_STATE + "");
            }
        }

        for (final FilterCategory filterCategory : filter.getFilterCategories()) {
            final Category category = filterCategory.getCategory();
            final Project project = filterCategory.getProject();

            if (filterCategory.getCategoryState() == CommonFilterConstants.CATEGORY_INTERNAL_AND_STATE) {
                vars.put(
                        CommonFilterConstants.CATEORY_INTERNAL_LOGIC + category.getCategoryId() + (project == null ? "" : "-" + project
                                .getProjectId()),
                        CommonFilterConstants.AND_LOGIC);
            }

            // don't add a url var for the "or" internal logic, as this is the
            // default

            else if (filterCategory.getCategoryState() == CommonFilterConstants.CATEGORY_EXTERNAL_OR_STATE) {
                vars.put(
                        CommonFilterConstants.CATEORY_EXTERNAL_LOGIC + category.getCategoryId() + (project == null ? "" : "-" + project
                                .getProjectId()),
                        CommonFilterConstants.OR_LOGIC);
            }

            // don't add a url var for the "and" external logic, as this is the
            // default
        }

        int count = 1;
        for (final FilterLocale filterLocale : filter.getFilterLocales()) {
            final Integer localeState = filterLocale.getLocaleState();

            if (localeState == CommonFilterConstants.MATCH_TAG_STATE) {
                vars.put(CommonFilterConstants.MATCH_LOCALE + count, filterLocale.getLocaleName() + CommonFilterConstants.MATCH_TAG_STATE);
            } else if (localeState == CommonFilterConstants.NOT_MATCH_TAG_STATE) {
                vars.put(CommonFilterConstants.MATCH_LOCALE + count,
                        filterLocale.getLocaleName() + CommonFilterConstants.NOT_MATCH_TAG_STATE);
            }
            count++;
        }

        boolean foundFilterField = false;
        boolean foundFilterFieldLogic = false;
        for (final FilterField filterField : filter.getFilterFields()) {
            try {
                vars.put(filterField.getField(), URLEncoder.encode(filterField.getValue(), "UTF-8"));
            } catch (UnsupportedEncodingException e) {
                throw new RuntimeException(e);
            }
            if (!filterField.getField().equals(CommonFilterConstants.LOGIC_FILTER_VAR)) foundFilterField = true;
            else foundFilterFieldLogic = true;
        }

        /*
         * if we have found some filter fields, but did not find the filter
         * logic, use the default value
         */
        if (foundFilterField && !foundFilterFieldLogic)
            vars.put(CommonFilterConstants.LOGIC_FILTER_VAR, FilterConstants.LOGIC_FILTER_VAR_DEFAULT_VALUE);

        return vars;
    }
1356374
public static vrid6[] get_filtered(nitro_service service, String filter) throws Exception{
		vrid6 obj = new vrid6();
		options option = new options();
		option.set_filter(filter);
		vrid6[] response = (vrid6[]) obj.getfiltered(service, option);
		return response;
	}
170901
public static hostcpu[] get_filtered(nitro_service service, String filter) throws Exception
	{
		hostcpu obj = new hostcpu();
		options option = new options();
		option.set_filter(filter);
		hostcpu[] response = (hostcpu[]) obj.getfiltered(service, option);
		return response;
	}
974077
@GET
    @Path("{uuid}")
    public Penalty getPenaltyByUuid(@PathParam("uuid") UUID uuid) {
        logger.debug("StartOf getPenaltyByUuid - REQUEST for /penalties/{}", uuid);
        PenaltyHelperE penaltyRestHelper = getPenaltyHelper();
        Penalty result = penaltyRestHelper.getPenaltyByUuid(uuid);
        logger.debug("EndOf getPenaltyByUuid");
        return result;
    }
846646
@RequestMapping(value = "branches/{branchId}/filters", method = RequestMethod.GET)
    public Resources<BuildFilterResource<?>> buildFilters(@PathVariable ID branchId) {
        return Resources.of(
                buildFilterService.getBuildFilters(branchId),
                uri(on(getClass()).buildFilters(branchId))
        );
    }
68946
@RequestMapping(value = "/api/path/{pathIdentifier}", method = RequestMethod.GET)
    @ResponseBody
    public EndpointOverride getPath(Model model,
                                    @PathVariable String pathIdentifier,
                                    @RequestParam(required = false) String profileIdentifier,
                                    @RequestParam(value = "typeFilter[]", required = false) String[] typeFilter,
                                    @RequestParam(value = "clientUUID", defaultValue = Constants.PROFILE_CLIENT_DEFAULT_ID) String clientUUID) throws Exception {
        Identifiers identifiers = ControllerUtils.convertProfileAndPathIdentifier(profileIdentifier, pathIdentifier);

        return PathOverrideService.getInstance().getPath(identifiers.getPathId(), clientUUID, typeFilter);
    }
733937
public static StepContextFetcher fetcher(final String pathFlowSid, 
                                             final String pathEngagementSid, 
                                             final String pathStepSid) {
        return new StepContextFetcher(pathFlowSid, pathEngagementSid, pathStepSid);
    }
1181123
public static vrid[] get_filtered(nitro_service service, String filter) throws Exception{
		vrid obj = new vrid();
		options option = new options();
		option.set_filter(filter);
		vrid[] response = (vrid[]) obj.getfiltered(service, option);
		return response;
	}