Return a list of resource model configuration

@param serviceName
@param keyprefix   prefix for properties
@return List of Maps, each map containing "type": String, "props":Properties
189560
public List<ExtPluginConfiguration> listPluginConfigurations(
            final String keyprefix,
            final String serviceName,
            boolean extra
    )
    {
        return listPluginConfigurations(projectConfig.getProjectProperties(), keyprefix, serviceName, extra);
    }
288610
protected static Properties getComponentProperties(String componentPrefix, Properties properties) {
        Properties result = new Properties();
        if (null != componentPrefix) {
            int componentPrefixLength = componentPrefix.length();
            for (String propertyName : properties.stringPropertyNames()) {
                if (propertyName.startsWith(componentPrefix)) {
                    result.put(propertyName.substring(componentPrefixLength), properties.getProperty(propertyName));
                }
            }
        }
        return result;
    }
219432
public static Map<String, ?> propsToStringKeyMap(Properties properties) {
    ImmutableMap.Builder<String, Object> mapBuilder = ImmutableMap.builder();
    for (Map.Entry<Object, Object> entry : properties.entrySet()) {
      mapBuilder.put(entry.getKey().toString(), entry.getValue());
    }
    return mapBuilder.build();
  }
52830
private <T extends AnnotatedElement> Map<T, PropertyInfo> resolveConfig(String keyPrefix, T element,
                                                                            Set<Class> resolvedConfigs) {
        Map<T, PropertyInfo> result = new HashMap<>();
        if (!element.isAnnotationPresent(Config.class)) {
            return result;
        }
        String prefix = concat(keyPrefix, element.getAnnotation(Config.class).prefix());

        Class<?> returnType = getValueType(element);
        checkRecursiveConfigs(resolvedConfigs, returnType);
        resolvedConfigs.add(returnType);

        Object proxy = populate(prefix, returnType, resolvedConfigs);
        result.put(element, new PropertyInfo(proxy));
        return result;
    }
278594
@Override
	protected Class<?>[] getHandlerInterfaces(String serviceName) {
		Class<?> remoteInterface = interfaceMap.get(serviceName);
		if (remoteInterface != null) {
			return new Class<?>[]{remoteInterface};
		} else if (Proxy.isProxyClass(getHandler(serviceName).getClass())) {
			return getHandler(serviceName).getClass().getInterfaces();
		} else {
			return new Class<?>[]{getHandler(serviceName).getClass()};
		}
	}
88473
function (methodName) {
            var parameters = this.smd.parameters || [];

            parameters = parameters.concat(this.smd.services[methodName].parameters || []);

            return parameters;
        }
406461
@Override
    public synchronized List<ExtPluginConfiguration> listResourceModelPluginConfigurations() {
        return listPluginConfigurations(
                projectConfig.getProjectProperties(),
                RESOURCES_SOURCE_PROP_PREFIX,
                ServiceNameConstants.ResourceModelSource
        );
    }
706402
public Map<String, Class<?>> getPayloadPropertyNames(Map<String,Class<?>> mapPropertyNames)
    {
        mapPropertyNames = super.getPayloadPropertyNames(mapPropertyNames);
        if ((this.getKeyInformation() & STANDARD_PARAM) != 0)
        {   // Add this name and class to the map of property names
            if (mapPropertyNames == null)
                mapPropertyNames = new HashMap<String, Class<?>>();
            mapPropertyNames.put(this.getFullKey(null), this.getRawClassType());
        }
        return mapPropertyNames;
    }
104532
public Dictionary<String, ?> getServiceProperties() {
        Dictionary<String, String> props = new Hashtable<>();
        props.put("name", name());
        props.put("fullName", fullName());
        props.put("mimetype", mimetype());
        props.put("engine", engine());
        return props;
    }
165792
public static String getFileNamePrefix(ServiceModel serviceModel, CustomizationConfig customizationConfig) {
        if (customizationConfig.isUseUidAsFilePrefix() && serviceModel.getMetadata().getUid() != null) {
            return serviceModel.getMetadata().getUid();
        }

        return String.format("%s-%s", serviceModel.getMetadata().getEndpointPrefix(), serviceModel.getMetadata().getApiVersion());
    }
433831
public static Map<String, String> convertPropertiesToServerFormat(
        CmsObject cms,
        Map<String, String> props,
        Map<String, CmsXmlContentProperty> propConfig) {

        return convertProperties(cms, props, propConfig, false);
    }
1292529
static Set<String> serviceNames(Service<HttpRequest, HttpResponse> service) {
        if (thriftServiceClass == null || entriesMethod == null || interfacesMethod == null) {
            return ImmutableSet.of();
        }
        return service.as(thriftServiceClass)
                      .map(s -> {
                          @SuppressWarnings("unchecked")
                          final Map<String, ?> entries = (Map<String, ?>) invokeMethod(entriesMethod, s);
                          assert entries != null;
                          return toServiceName(entries.values());
                      })
                      .orElse(ImmutableSet.of());
    }
806460
public Map<String, Object> getApplicationProperties(Map<String, Object> properties)
    {
        if (properties == null)
            return null;
        Map<String, Object> propApp = new Hashtable<String,Object>();
        if (properties.get(DBParams.LANGUAGE) != null)
            propApp.put(DBParams.LANGUAGE, properties.get(DBParams.LANGUAGE));
        if (properties.get(DBParams.DOMAIN) != null)
            propApp.put(DBParams.DOMAIN, properties.get(DBParams.DOMAIN));
        return propApp;
    }
800712
public static Map<String, ?> getMapFromProperties(Properties properties, String prefix) {
        Map<String, Object> result = new HashMap<String, Object>();
        for (String key : properties.stringPropertyNames()) {
            if (key.startsWith(prefix)) {
                String name = key.substring(prefix.length());
                result.put(name, properties.getProperty(key));
            }
        }
        return result;
    }
855382
function(services) {

    return _.map(services, function(service) {

      // Start with a hostnames collector
      var hostnames = [];

      // Handle 'default' key
      if (service.default) {
        hostnames.push(app.name);
      }

      // Handle legacy 'hostname' key
      if (service.hostname) {
        hostnames.push([service.hostname, app.name].join('.'));
      }

      // Handle 'subdomains'
      if (service.subdomains) {
        _.forEach(service.subdomains, function(subdomain) {
          hostnames.push([subdomain, app.name].join('.'));
        });
      }

      // Handle 'custom'
      if (service.custom) {
        _.forEach(service.custom, function(url) {
          hostnames.push(url);
        });
      }

      // Determine whether the protocol is http or https
      var protocol = (service.secure) ? 'https://' : 'http://';

      // Return an array of parsed hostnames
      return _.map(hostnames, function(hostname) {
        return protocol + [hostname, app.domain].join('.');
      });

    });

  }
26518
public Map<String,Object> getServiceProperties()
    {
        Map<String,Object> properties = super.getServiceProperties();
        properties = addConfigProperty(properties, DBParams.LOCAL, DBParams.JDBC); // Remote Server ALWAYS uses Jdbc
        properties = addConfigProperty(properties, DBParams.REMOTE, DBParams.JDBC);
        properties = addConfigProperty(properties, DBParams.TABLE, DBParams.JDBC);
        properties = addConfigProperty(properties, Params.APP_NAME, Params.DEFAULT_REMOTE_APP);
        properties = addConfigProperty(properties, Params.MESSAGE_SERVER, DBConstants.TRUE);
        properties = addConfigProperty(properties, DBParams.FREEIFDONE, Constants.FALSE);   // Don't free when only the last app is running.
        properties = addConfigProperty(properties, MessageConstants.MESSAGE_FILTER, MessageConstants.TREE_FILTER);  // Default for a server
        return properties;
    }
488287
public ModelService lookupService(String serviceName){
        HttpResponse result = invoker.invoke("/service/" + serviceName , null, HttpMethod.GET);

        if (result.getHttpCode() != HTTP_OK) {
            throw new ServiceException(ErrorCode.REMOTE_DIRECTORY_SERVER_ERROR,
                    "HTTP Code is not OK, code=%s", result.getHttpCode());
        }

        ModelService service = _deserialize(result.getRetBody(), ModelService.class);
        return service;
    }