Returns the information of an specific penalty given an uuid.

@return violations according to parameters in the query string.
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;
    }
253244
public String getInvalidPinCode() {
        for (HBCIRetVal hbciRetVal : globStatus.getErrors()) {
            if (invalidPinCodes.contains(hbciRetVal.code)) {
                return hbciRetVal.code;
            }
        }

        for (HBCIRetVal hbciRetVal : segStatus.getErrors()) {
            if (invalidPinCodes.contains(hbciRetVal.code)) {
                return hbciRetVal.code;
            }
        }

        return null;
    }
175538
public static Optional<String> isRequestEntity(ConstraintViolation<?> violation, Invocable invocable) {
        final Collection<Path.Node> propertyPath = Lists.of(violation.getPropertyPath());
        final Path.Node parent = propertyPath.stream()
                .skip(1L)
                .findFirst()
                .orElse(null);
        if (parent == null) {
            return Optional.empty();
        }
        final List<Parameter> parameters = invocable.getParameters();

        if (parent.getKind() == ElementKind.PARAMETER) {
            final Parameter param = parameters.get(parent.as(Path.ParameterNode.class).getParameterIndex());
            if (param.getSource().equals(Parameter.Source.UNKNOWN)) {
                final String path = propertyPath.stream()
                        .skip(2L)
                        .map(Path.Node::toString)
                        .collect(Collectors.joining("."));

                return Optional.of(path);
            }
        }

        return Optional.empty();
    }
807551
public java.lang.String getUrlQueryParameter() {
    java.lang.Object ref = urlQueryParameter_;
    if (ref instanceof java.lang.String) {
      return (java.lang.String) ref;
    } else {
      com.google.protobuf.ByteString bs = 
          (com.google.protobuf.ByteString) ref;
      java.lang.String s = bs.toStringUtf8();
      urlQueryParameter_ = s;
      return s;
    }
  }
1068224
public void checkInvalidParameters() {
    	for(String key: map.keySet()) {
    		boolean wasRequested = requestedKeys != null && requestedKeys.contains(key);
    		if(!wasRequested) throw new IllegalArgumentException("Unknown parameter " + key);
    		
    	}
    }
1154412
private String httpQuery() {

		String response = null;
		try {
			URL restUrl = new URL( this.url );
			HttpURLConnection conn = (HttpURLConnection) restUrl.openConnection();
			response = query( conn );

		} catch( Exception e ) {
			this.logger.severe( "Cannot issue GET on URL " + this.url + ". Monitoring notification is discarded." );
			Utils.logException(this.logger, e);
		}

		return response;
	}
358424
public EntityType getRefEntity() {
    if (!hasRefEntity()) {
      throw new UnsupportedOperationException(
          String.format("getRefEntity not supported for attribute type '%s'", getDataType()));
    }
    return getEntity(REF_ENTITY_TYPE, EntityType.class);
  }
941951
public static Map<String,String> getQueryKeyValuePairs(URI uri) throws UnsupportedEncodingException {
        Map<String,String> queryParameters = new HashMap<String, String>();
        String query = uri.getRawQuery();
        if(query == null) {
            // Maybe invalid URI
            try {
                uri = URI.create(uri.getRawSchemeSpecificPart());
                query = uri.getRawQuery();
                if(query == null) {
                    return queryParameters;
                }
            } catch (IllegalArgumentException ex) {
                return queryParameters;
            }
        }
        StringTokenizer stringTokenizer = new StringTokenizer(query, "&");
        while (stringTokenizer.hasMoreTokens()) {
            String keyValue = stringTokenizer.nextToken().trim();
            if(!keyValue.isEmpty()) {
                int equalPos = keyValue.indexOf("=");
                // If there is no value
                String key = URLDecoder.decode(keyValue.substring(0,equalPos != -1 ?
                        equalPos : keyValue.length()), ENCODING);
                if(equalPos==-1 || equalPos == keyValue.length() - 1) {
                    // Key without value
                    queryParameters.put(key.toLowerCase(),"");
                } else {
                    String value = URLDecoder.decode(keyValue.substring(equalPos+1), ENCODING);
                    queryParameters.put(key.toLowerCase(),value);
                }
            }
        }
        return queryParameters;
    }
805923
public Map<String, String[]> getParameters() {
		final MultivaluedMap<String, String> queryParameters = getUriInfo().getQueryParameters();
		final HashMap<String, String[]> params = new HashMap<String, String[]>();
		for (final Entry<String, List<String>> paramEntry : queryParameters.entrySet()) {
			params.put(paramEntry.getKey(), paramEntry.getValue().toArray(new String[paramEntry.getValue().size()]));
		}
		return params;
	}
558538
public int getMessageLength() {
    // Message type, ticket #
    int messageLength = 1 + 4;

    // Identifier length prefix
    messageLength += 4;

    if (this.identifierRegex != null) {
      try {
        messageLength += this.identifierRegex.getBytes("UTF-16BE").length;
      } catch (UnsupportedEncodingException e) {
        log.error("Unable to encode String into UTF-16.");
        e.printStackTrace();
      }
    }

    // Number of query attributes length prefix
    messageLength += 4;

    // Add length prefix and String length for each attribute
    if (this.attributeRegexes != null) {
      for (String attrib : this.attributeRegexes) {
        messageLength += 4;
        try {
          messageLength += attrib.getBytes("UTF-16BE").length;
        } catch (UnsupportedEncodingException e) {
          log.error("Unable to encode String into uTF-16");
          e.printStackTrace();
        }
      }
    }

    // Begin and end timestamps
    messageLength += 16;

    return messageLength;
  }
227852
public Map<String, String> getUriVariablesForQuery(BullhornEntityInfo entityInfo, String where, Set<String> fieldSet, QueryParams params) {

		Map<String, String> uriVariables = params.getParameterMap();

		this.addCommonUriVariables(fieldSet, entityInfo, uriVariables);
		uriVariables.put(WHERE, where);

		return uriVariables;
	}
1290553
public com.google.rpc.PreconditionFailure.ViolationOrBuilder getViolationsOrBuilder(
      int index) {
    return violations_.get(index);
  }
162194
@Override
    public Map<String, Object> getQueryParameters() {
        HashMap<String, Object> params = new HashMap<String, Object>();
        params.put("userId", this.userId.toString());
        params.put("itemId", this.itemId.toString());
        if (this.sessionId!=null) {
            params.put("sessionId", this.sessionId.toString());
        }
        return params;
    }
1170423
protected function getAllowedQueryParameters()
    {
        $queryParameters = QueryService::getDefaultQueryParameters();
        $customParameters = $this->getCustomQueryParameters();

        if (is_array($customParameters) && count($customParameters) > 0) {
            $queryParameters = array_merge($queryParameters, $customParameters);
        }

        return $queryParameters;
    }
291108
public static RequestToken fetchAll(BaasQuery.Criteria filter, int flags, BaasHandler<List<BaasUser>> handler) {
        BaasBox box = BaasBox.getDefaultChecked();
        FetchUsers users = new FetchUsers(box, "users", null, filter, flags, handler);
        return box.submitAsync(users);
    }
41853
protected final int getMeq(){
		if(meq < 0){
			meq = (this.request.getA()==null)? 0 : this.request.getA().rows();
		}
		return meq;
	}
73020
public function checkRegistryRequestsAnswers()
    {

        if (! $this->organizationId) {
            if ($this->respondent) {
                $this->organizationId = $this->respondent->getOrganizationId();
            }
            if (! $this->organizationId) {
                $this->organizationId = $this->request->getParam(\MUtil_Model::REQUEST_ID2);
            }
        }

        if ($this->organizationId && (! $this->respondentId)) {
            if ($this->respondent) {
                $this->respondentId = $this->respondent->getId();
            }
            if (! $this->respondentId) {
                $this->respondentId = $this->util->getDbLookup()->getRespondentId(
                        $this->request->getParam(\MUtil_Model::REQUEST_ID1),
                        $this->organizationId
                        );
            }
        }

        return $this->organizationId && $this->respondentId && $this->db && $this->model;
    }