/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.ranger.services.atlas;

import java.security.PrivilegedAction;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.google.gson.Gson;
import com.sun.jersey.api.client.Client;
import com.sun.jersey.api.client.ClientResponse;
import com.sun.jersey.api.client.WebResource;
import com.sun.jersey.core.util.MultivaluedMapImpl;
import org.apache.atlas.model.discovery.AtlasSearchResult;
import org.apache.atlas.model.instance.AtlasEntityHeader;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.io.IOCase;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.ranger.plugin.client.BaseClient;
import org.apache.ranger.plugin.client.HadoopException;
import org.apache.ranger.plugin.model.RangerPolicy;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItem;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyItemAccess;
import org.apache.ranger.plugin.model.RangerPolicy.RangerPolicyResource;
import org.apache.ranger.plugin.model.RangerService;
import org.apache.ranger.plugin.model.RangerServiceDef;
import org.apache.ranger.plugin.policyengine.RangerPolicyEngine;
import org.apache.ranger.plugin.service.RangerBaseService;
import org.apache.ranger.plugin.service.ResourceLookupContext;
import org.apache.ranger.plugin.util.PasswordUtils;
import javax.security.auth.Subject;
import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.NewCookie;

public class RangerServiceAtlas extends RangerBaseService {
	private static final Log LOG = LogFactory.getLog(RangerServiceAtlas.class);

	public static final String RESOURCE_SERVICE                       = "atlas-service";
	public static final String RESOURCE_TYPE_CATEGORY                 = "type-category";
	public static final String RESOURCE_TYPE_NAME                     = "type";
	public static final String RESOURCE_ENTITY_TYPE                   = "entity-type";
	public static final String RESOURCE_ENTITY_CLASSIFICATION         = "entity-classification";
	public static final String RESOURCE_ENTITY_ID                     = "entity";
	public static final String RESOURCE_ENTITY_LABEL                  = "entity-label";
	public static final String RESOURCE_ENTITY_NAMESPACE              = "entity-namespace";
	public static final String RESOURCE_ENTITY_OWNER                  = "owner";
	public static final String RESOURCE_RELATIONSHIP_TYPE             = "relationship-type";
	public static final String RESOURCE_END_ONE_ENTITY_TYPE           = "end-one-entity-type";
	public static final String RESOURCE_END_ONE_ENTITY_CLASSIFICATION = "end-one-entity-classification";
	public static final String RESOURCE_END_ONE_ENTITY_ID             = "end-one-entity";
	public static final String RESOURCE_END_TWO_ENTITY_TYPE           =  "end-two-entity-type";
	public static final String RESOURCE_END_TWO_ENTITY_CLASSIFICATION = "end-two-entity-classification";
	public static final String RESOURCE_END_TWO_ENTITY_ID             = "end-two-entity";
	public static final String SEARCH_FEATURE_POLICY_NAME             = "Allow users to manage favorite searches";

	public static final String ACCESS_TYPE_ENTITY_READ  = "entity-read";
	public static final String ACCESS_TYPE_ENTITY_CREATE  = "entity-create";
	public static final String ACCESS_TYPE_ENTITY_UPDATE = "entity-update";
	public static final String ACCESS_TYPE_ENTITY_DELETE = "entity-delete";
	public static final String ADMIN_USERNAME_DEFAULT   = "admin";
	public static final String TAGSYNC_USERNAME_DEFAULT = "rangertagsync";
	public static final String ENTITY_TYPE_USER_PROFILE = "__AtlasUserProfile";
	public static final String ENTITY_TYPE_SAVED_SEARCH = "__AtlasUserSavedSearch";
	public static final String ENTITY_ID_USER_PROFILE = RangerPolicyEngine.USER_CURRENT;
	public static final String ENTITY_ID_USER_SAVED_SEARCH= RangerPolicyEngine.USER_CURRENT + ":*";


	public static final String CONFIG_REST_ADDRESS            = "atlas.rest.address";
	public static final String CONFIG_USERNAME                = "username";
	public static final String CONFIG_PASSWORD                = "password";
	public static final String ENTITY_NOT_CLASSIFIED          = "_NOT_CLASSIFIED";

	private static final String TYPE_ENTITY         = "entity";
	private static final String TYPE_CLASSIFICATION = "classification";
	private static final String TYPE_STRUCT         = "struct";
	private static final String TYPE_ENUM           = "enum";
	private static final String TYPE_RELATIONSHIP   = "relationship";

	private static final String URL_LOGIN                = "/j_spring_security_check";
	private static final String URL_GET_TYPESDEF_HEADERS = "/api/atlas/v2/types/typedefs/headers";
	private static final String URl_ENTITY_SEARCH        = "v2/search/attribute?attrName=qualifiedName";

	private static final String WEB_RESOURCE_CONTENT_TYPE = "application/x-www-form-urlencoded";
	private static final String CONNECTION_ERROR_MSG      =   " You can still save the repository and start creating"
	                                                        + " policies, but you would not be able to use autocomplete for"
	                                                        + " resource names. Check ranger_admin.log for more info.";

	public RangerServiceAtlas() {
		super();
	}

	@Override
	public void init(RangerServiceDef serviceDef, RangerService service) {
		super.init(serviceDef, service);
	}

	@Override
	public Map<String, Object> validateConfig() throws Exception {
		if (LOG.isDebugEnabled()) {
			LOG.debug("==> RangerServiceAtlas.validateConfig()");
		}

		AtlasServiceClient  client = new AtlasServiceClient(getServiceName(), configs);
		Map<String, Object> ret    = client.validateConfig();

		if (LOG.isDebugEnabled()) {
			LOG.debug("<== RangerServiceAtlas.validateConfig(): " + ret );
		}

		return ret;
	}

	@Override
	public List<String> lookupResource(ResourceLookupContext context)throws Exception {
		if (LOG.isDebugEnabled()) {
			LOG.debug("==> RangerServiceAtlas.lookupResource(" + context + ")");
		}

		AtlasServiceClient client = new AtlasServiceClient(getServiceName(), configs);
		List<String>       ret    = client.lookupResource(context);

		if (LOG.isDebugEnabled()) {
			LOG.debug("<== RangerServiceAtlas.lookupResource("+ context + "): " + ret);
		}

		return ret;
	}

    @Override
    public List<RangerPolicy> getDefaultRangerPolicies() throws Exception {
        if (LOG.isDebugEnabled()) {
            LOG.debug("==> RangerServiceAtlas.getDefaultRangerPolicies()");
        }

        List<RangerPolicy> ret                         = super.getDefaultRangerPolicies();
        String             adminUser                   = getStringConfig("atlas.admin.user", ADMIN_USERNAME_DEFAULT);
        String             tagSyncUser                 = getStringConfig("atlas.rangertagsync.user", TAGSYNC_USERNAME_DEFAULT);

        boolean            relationshipTypeAllowPublic = getBooleanConfig("atlas.default-policy.relationship-type.allow.public", true);


        for (RangerPolicy defaultPolicy : ret) {
            final Map<String, RangerPolicyResource> policyResources = defaultPolicy.getResources();

            // 1. add adminUser to every policyItem
            for (RangerPolicyItem defaultPolicyItem : defaultPolicy.getPolicyItems()) {
                defaultPolicyItem.getUsers().add(adminUser);
            }

            // 2. add a policy-item for rangertagsync user with 'entity-read' permission in the policy for 'entity-type'
            if (policyResources.containsKey(RangerServiceAtlas.RESOURCE_ENTITY_TYPE)) {
                RangerPolicyItem policyItemForTagSyncUser = new RangerPolicyItem();

                policyItemForTagSyncUser.setUsers(Collections.singletonList(tagSyncUser));
                policyItemForTagSyncUser.setGroups(Collections.singletonList(RangerPolicyEngine.GROUP_PUBLIC));
                policyItemForTagSyncUser.setAccesses(Collections.singletonList(new RangerPolicyItemAccess(ACCESS_TYPE_ENTITY_READ)));

                defaultPolicy.getPolicyItems().add(policyItemForTagSyncUser);
            }

            if (relationshipTypeAllowPublic) {
                // 3. add 'public' group in the policy for 'relationship-type',
                if (policyResources.containsKey(RangerServiceAtlas.RESOURCE_RELATIONSHIP_TYPE)) {
                    for (RangerPolicyItem defaultPolicyItem : defaultPolicy.getPolicyItems()) {
                        defaultPolicyItem.getGroups().add(RangerPolicyEngine.GROUP_PUBLIC);
                    }
                }
            }

			if (defaultPolicy.getName().contains("all")
					&& policyResources.containsKey(RangerServiceAtlas.RESOURCE_ENTITY_TYPE)
					&& StringUtils.isNotBlank(lookUpUser)) {
				RangerPolicyItem policyItemForLookupUser = new RangerPolicyItem();
				policyItemForLookupUser.setUsers(Collections.singletonList(lookUpUser));
				policyItemForLookupUser.setAccesses(Collections.singletonList(new RangerPolicyItemAccess(ACCESS_TYPE_ENTITY_READ)));
				policyItemForLookupUser.setDelegateAdmin(false);
				defaultPolicy.getPolicyItems().add(policyItemForLookupUser);
			}
        }

        //4.add new policy for public group with entity-read, entity-create, entity-update, entity-delete for  __AtlasUserProfile, __AtlasUserSavedSearch entity type
        RangerPolicy searchFeaturePolicy = getSearchFeaturePolicy();
        ret.add(searchFeaturePolicy);
        if (LOG.isDebugEnabled()) {
            LOG.debug("<== RangerServiceAtlas.getDefaultRangerPolicies()");
        }

        return ret;
    }

	private RangerPolicy getSearchFeaturePolicy() {
		RangerPolicy searchFeaturePolicy = new RangerPolicy();

		searchFeaturePolicy.setName(SEARCH_FEATURE_POLICY_NAME);
		searchFeaturePolicy.setService(serviceName);
		searchFeaturePolicy.setResources(getSearchFeaturePolicyResource());
		searchFeaturePolicy.setPolicyItems(getSearchFeaturePolicyItem());

		return searchFeaturePolicy;
	}

	private List<RangerPolicyItem> getSearchFeaturePolicyItem() {
		List<RangerPolicyItemAccess> accesses = new ArrayList<RangerPolicyItemAccess>();

		accesses.add(new RangerPolicyItemAccess(ACCESS_TYPE_ENTITY_READ));
		accesses.add(new RangerPolicyItemAccess(ACCESS_TYPE_ENTITY_CREATE));
		accesses.add(new RangerPolicyItemAccess(ACCESS_TYPE_ENTITY_UPDATE));
		accesses.add(new RangerPolicyItemAccess(ACCESS_TYPE_ENTITY_DELETE));

		RangerPolicyItem item = new RangerPolicyItem(accesses, Arrays.asList(RangerPolicyEngine.USER_CURRENT), null, null, null, false);

		return Collections.singletonList(item);
	}

	private Map<String, RangerPolicyResource> getSearchFeaturePolicyResource() {
		Map<String, RangerPolicyResource> resources = new HashMap<>();

		resources.put(RESOURCE_ENTITY_TYPE, new RangerPolicyResource(Arrays.asList(ENTITY_TYPE_USER_PROFILE, ENTITY_TYPE_SAVED_SEARCH), false, false));
		resources.put(RESOURCE_ENTITY_CLASSIFICATION, new RangerPolicyResource("*"));
		resources.put(RESOURCE_ENTITY_ID, new RangerPolicyResource(Arrays.asList(ENTITY_ID_USER_PROFILE, ENTITY_ID_USER_SAVED_SEARCH), false, false));

		return resources;
	}

	private static class AtlasServiceClient extends BaseClient {
		private static final String[] TYPE_CATEGORIES = new String[] { "classification", "enum", "entity", "relationship", "struct" };

		Map<String, List<String>> typesDef = new HashMap<>();

		public AtlasServiceClient(String serviceName, Map<String, String> serviceConfig) {
			super(serviceName, serviceConfig);
		}

		public Map<String, Object> validateConfig() {
			Map<String, Object> ret = new HashMap<>();

			loginToAtlas(Client.create());

			BaseClient.generateResponseDataMap(true, "ConnectionTest Successful", "ConnectionTest Successful", null, null, ret);

			return ret;
		}

		public List<String> lookupResource(ResourceLookupContext lookupContext) {
			final List<String> ret           = new ArrayList<>();
			final String       userInput     = lookupContext.getUserInput();
			final List<String> currentValues = lookupContext.getResources().get(lookupContext.getResourceName());

			switch(lookupContext.getResourceName()) {
				case RESOURCE_TYPE_CATEGORY: {
					for (String typeCategory : TYPE_CATEGORIES) {
						addIfStartsWithAndNotExcluded(ret, typeCategory, userInput, currentValues);
					}
				}
				break;

				case RESOURCE_TYPE_NAME: {
					refreshTypesDefs();

					final List<String> typeCategories = lookupContext.getResources().get(RESOURCE_TYPE_CATEGORY);

					if (emptyOrContainsMatch(typeCategories, TYPE_CLASSIFICATION)) {
						addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_CLASSIFICATION), userInput, currentValues);
					}

					if (emptyOrContainsMatch(typeCategories, TYPE_ENTITY)) {
						addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_ENTITY), userInput, currentValues);
					}

					if (emptyOrContainsMatch(typeCategories, TYPE_ENUM)) {
						addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_ENUM), userInput, currentValues);
					}

					if (emptyOrContainsMatch(typeCategories, TYPE_STRUCT)) {
						addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_STRUCT), userInput, currentValues);
					}

					if (emptyOrContainsMatch(typeCategories, TYPE_RELATIONSHIP)) {
						addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_RELATIONSHIP), userInput, currentValues);
					}
				}
				break;

				case RESOURCE_END_ONE_ENTITY_TYPE:
				case RESOURCE_END_TWO_ENTITY_TYPE:
				case RESOURCE_ENTITY_TYPE: {
					refreshTypesDefs();

					addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_ENTITY), userInput, currentValues);
				}
				break;

				case RESOURCE_END_ONE_ENTITY_CLASSIFICATION:
				case RESOURCE_END_TWO_ENTITY_CLASSIFICATION:
				case RESOURCE_ENTITY_CLASSIFICATION: {
					refreshTypesDefs();

					addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_CLASSIFICATION), userInput, currentValues);
				}
                break;

				case RESOURCE_ENTITY_ID: {
					List<String> searchTypes = lookupContext.getResources().get("entity-type");

					if (searchTypes != null && searchTypes.size() == 1) {
						List<String> values = searchEntities(userInput, searchTypes.get(0));

						addIfStartsWithAndNotExcluded(ret, values, userInput, currentValues);
					}
				}
				break;

				case RESOURCE_RELATIONSHIP_TYPE: {
					refreshTypesDefs();
					addIfStartsWithAndNotExcluded(ret, typesDef.get(TYPE_RELATIONSHIP), userInput, currentValues);

				}
				break;

				case RESOURCE_END_ONE_ENTITY_ID: {

					List<String> searchTypes = lookupContext.getResources().get(RESOURCE_END_ONE_ENTITY_TYPE);

					if (searchTypes != null && searchTypes.size() == 1) {
						List<String> values = searchEntities(userInput, searchTypes.get(0));

						addIfStartsWithAndNotExcluded(ret, values, userInput, currentValues);
					}

				}
				break;

				case RESOURCE_END_TWO_ENTITY_ID: {
					List<String> searchTypes = lookupContext.getResources().get(RESOURCE_END_TWO_ENTITY_TYPE);

					if (searchTypes != null && searchTypes.size() == 1) {
						List<String> values = searchEntities(userInput, searchTypes.get(0));

						addIfStartsWithAndNotExcluded(ret, values, userInput, currentValues);
					}
				}
				break;

				default: {
					ret.add(lookupContext.getResourceName());
				}
			}

			return ret;
		}

		private ClientResponse loginToAtlas(Client client) {
			ClientResponse ret      = null;
			HadoopException excp     = null;
			String          loginUrl = null;

			for (String atlasUrl : getAtlasUrls()) {
				try {
					loginUrl = atlasUrl + URL_LOGIN;

					WebResource                    webResource = client.resource(loginUrl);
					MultivaluedMap<String, String> formData    = new MultivaluedMapImpl();
					String                         password    = null;

					try {
						password = PasswordUtils.decryptPassword(getPassword());
					} catch (Exception ex) {
						LOG.info("Password decryption failed; trying Atlas connection with received password string");
					}

					if (password == null) {
						password = getPassword();
					}

					formData.add("j_username", getUserName());
					formData.add("j_password", password);

					try {
						ret = webResource.type(WEB_RESOURCE_CONTENT_TYPE).post(ClientResponse.class, formData);
					} catch (Exception e) {
						LOG.error("failed to login to Atlas at " + loginUrl, e);
					}

					if (ret != null) {
						break;
					}
				} catch (Throwable t) {
					String msgDesc = "Exception while login to Atlas at : " + loginUrl;

					LOG.error(msgDesc, t);

					excp = new HadoopException(msgDesc, t);

					excp.generateResponseDataMap(false, BaseClient.getMessage(t), msgDesc + CONNECTION_ERROR_MSG, null, null);
				}
			}

			if (ret == null) {
				if (excp == null) {
					String msgDesc = "Exception while login to Atlas at : " + loginUrl;

					excp = new HadoopException(msgDesc);

					excp.generateResponseDataMap(false, "", msgDesc + CONNECTION_ERROR_MSG, null, null);
				}

				throw excp;
			}

			return ret;
		}

		private boolean refreshTypesDefs() {
			boolean ret  = false;
			Subject subj = getLoginSubject();

			if (subj == null) {
				return ret;
			}

			Map<String, List<String>> typesDef = Subject.doAs(subj, new PrivilegedAction<Map<String, List<String>>>() {
				@Override
				public Map<String, List<String>> run() {
					Map<String, List<String>> ret  = null;

					for (String atlasUrl : getAtlasUrls()) {
						Client client = null;

						try {
							client = Client.create();

							ClientResponse      loginResponse = loginToAtlas(client);
							WebResource         webResource   = client.resource(atlasUrl + URL_GET_TYPESDEF_HEADERS);
							WebResource.Builder builder       = webResource.getRequestBuilder();

							for (NewCookie cook : loginResponse.getCookies()) {
								builder = builder.cookie(cook);
							}

							ClientResponse response = builder.get(ClientResponse.class);

							if (response != null) {
								String jsonString = response.getEntity(String.class);
								Gson   gson       = new Gson();
								List   types      = gson.fromJson(jsonString, List.class);

								ret = new HashMap<>();

								for (Object type : types) {
									if (type instanceof Map) {
										Map    typeDef  = (Map) type;
										Object name     = typeDef.get("name");
										Object category = typeDef.get("category");

										if (name != null && category != null) {
											String       strCategory  = category.toString().toLowerCase();
											List<String> categoryList = ret.get(strCategory);

											if (categoryList == null) {
												categoryList = new ArrayList<>();

												ret.put(strCategory, categoryList);
											}

											categoryList.add(name.toString());
										}
									}
								}

								break;
							}
						} catch (Throwable t) {
							String msgDesc = "Exception while getting Atlas Resource List.";

							LOG.error(msgDesc, t);
						} finally {
							if (client != null) {
								client.destroy();
							}
						}
					}

					return ret;
				}
			});

			if (typesDef != null) {
				this.typesDef = typesDef;

				ret = true;
			}

			return ret;
		}

		private List<String> searchEntities(String userInput, String entityType) {
			if( LOG.isDebugEnabled()) {
				LOG.debug("==> RangerServiceAtlas.searchEntities(userInput=" + userInput + ", entityType=" + entityType + ")");
			}

			Subject subj = getLoginSubject();

			if (subj == null) {
				return null;
			}

			List<String> list = Subject.doAs(subj, new PrivilegedAction<List<String>>() {
				@Override
				public List<String> run() {
					List<String> ret = null;

					for (String atlasUrl : getAtlasUrls()) {
						Client client = null;

						try {
							client = Client.create();

							ClientResponse loginResponse     = loginToAtlas(client);
							String         entitySearcApiUrl = atlasUrl + "/api/atlas/" + URl_ENTITY_SEARCH;
							StringBuilder  searchUrl         = new StringBuilder();

							searchUrl.append(entitySearcApiUrl)
									 .append("&typeName=")
									 .append(entityType)
									 .append("&attrValuePrefix=" + userInput + "&limit=25");


							WebResource         webResource = client.resource(searchUrl.toString());
							WebResource.Builder builder     = webResource.getRequestBuilder();

							for (NewCookie cook : loginResponse.getCookies()) {
								builder = builder.cookie(cook);
							}

							ClientResponse response = builder.get(ClientResponse.class);

							if (response != null) {
								String            jsonString   = response.getEntity(String.class);
								Gson              gson         = new Gson();
								AtlasSearchResult searchResult = gson.fromJson(jsonString, AtlasSearchResult.class);

								ret = new ArrayList<>();

								if (searchResult != null) {
									List<AtlasEntityHeader> entityHeaderList = searchResult.getEntities();

									for (AtlasEntityHeader entity : entityHeaderList) {
										ret.add((String) entity.getAttribute("qualifiedName"));
									}
								}
							}
						} catch (Throwable t) {
							String msgDesc = "Exception while getting Atlas Entity Resource List.";

							LOG.error(msgDesc, t);
						} finally {
							if (client != null) {
								client.destroy();
							}
						}
					}

					return ret;
				}
			});

			if (LOG.isDebugEnabled()) {
				LOG.debug("<== RangerServiceAtlas.searchEntities(userInput=" + userInput + ", entityType=" + entityType + "): " + list);
			}

			return list;
		}

		String[] getAtlasUrls() {
			String   urlString = connectionProperties.get(CONFIG_REST_ADDRESS);
			String[] ret       = urlString == null ? new String[0] : urlString.split(",");

			// remove separator at the end
			for (int i = 0; i < ret.length; i++) {
				String url = ret[i];

				while (url.length() > 0 && url.charAt(url.length() - 1) == '/') {
					url = url.substring(0, url.length() - 1);
				}

				ret[i] = url;
			}

			return ret;
		}

		String getUserName() {
			return connectionProperties.get(CONFIG_USERNAME);
		}

		String getPassword() {
			return connectionProperties.get(CONFIG_PASSWORD);
		}

		boolean emptyOrContainsMatch(List<String> list, String value) {
			if (list == null || list.isEmpty()) {
				return true;
			}

			for (String item : list) {
				if (StringUtils.equalsIgnoreCase(item, value) || FilenameUtils.wildcardMatch(value, item, IOCase.INSENSITIVE)) {
					return true;
				}
			}

			return false;
		}

		void addIfStartsWithAndNotExcluded(List<String> list, List<String> values, String prefix, List<String> excludeList) {
			if (list == null) {
				return;
			}

			if (values == null) {
				addIfStartsWithAndNotExcluded(list, ENTITY_NOT_CLASSIFIED, prefix, excludeList);
			} else {
				for (String value : values) {
					addIfStartsWithAndNotExcluded(list, value, prefix, excludeList);
				}
			}
		}

		void addIfStartsWithAndNotExcluded(List<String> list, String value, String prefix, List<String> excludeList) {
			if (value == null || list == null) {
				return;
			}

			if (prefix != null && !value.startsWith(prefix)) {
				return;
			}

			if (excludeList != null && excludeList.contains(value)) {
				return;
			}

			list.add(value);
		}
	}

	String getStringConfig(String configName, String defaultValue) {
		String val = service.getConfigs().get(configName);

		return StringUtils.isBlank(val) ? defaultValue : val;
	}

	boolean getBooleanConfig(String configName, boolean defaultValue) {
		String val = service.getConfigs().get(configName);

		return StringUtils.isBlank(val) ? defaultValue : Boolean.parseBoolean(val);
	}
}