org.ssssssss.magicapi.provider.impl.DefaultGroupServiceProvider Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of magic-api Show documentation
auto generate http api
There is a newer version: 2.1.1
package org.ssssssss.magicapi.provider.impl;

import org.apache.commons.lang3.StringUtils;
import org.ssssssss.magicapi.adapter.Resource;
import org.ssssssss.magicapi.model.Constants;
import org.ssssssss.magicapi.model.Group;
import org.ssssssss.magicapi.model.TreeNode;
import org.ssssssss.magicapi.provider.GroupServiceProvider;
import org.ssssssss.magicapi.utils.JsonUtils;
import org.ssssssss.magicapi.utils.PathUtils;

import java.util.*;
import java.util.stream.Collectors;

public class DefaultGroupServiceProvider implements GroupServiceProvider {

	private final Map mappings = new HashMap<>();
	private final Resource workspace;
	private Map cacheApiTree = new HashMap<>();
	private Map cacheFunctionTree = new HashMap<>();

	public DefaultGroupServiceProvider(Resource workspace) {
		this.workspace = workspace;
	}

	@Override
	public boolean insert(Group group) {
		if (StringUtils.isBlank(group.getId())) {
			group.setId(UUID.randomUUID().toString().replace("-", ""));
		}
		Resource directory = this.getGroupResource(group.getParentId());
		directory = directory == null ? this.getGroupResource(group.getType(), group.getName()) : directory.getDirectory(group.getName());
		if (!directory.exists() && directory.mkdir()) {
			Resource resource = directory.getResource(Constants.GROUP_METABASE);
			if (resource.write(JsonUtils.toJsonString(group))) {
				mappings.put(group.getId(), resource);
				return true;
			}
		}
		return false;
	}

	private Resource getGroupResource(String type, String name) {
		return this.workspace.getDirectory(Constants.GROUP_TYPE_API.equals(type) ? Constants.PATH_API : Constants.PATH_FUNCTION).getDirectory(name);
	}

	@Override
	public boolean update(Group group) {
		Resource oldResource = this.getGroupResource(group.getId());
		Resource newResource = this.getGroupResource(group.getParentId());
		newResource = newResource == null ? getGroupResource(group.getType(), group.getName()) : newResource.getDirectory(group.getName());
		// 重命名或移动目录
		if (oldResource.renameTo(newResource)) {
			Resource target = newResource.getResource(Constants.GROUP_METABASE);
			if (target.write(JsonUtils.toJsonString(group))) {
				mappings.put(group.getId(), target);
				return true;
			}
		}
		return false;
	}

	@Override
	public boolean delete(String groupId) {
		mappings.remove(groupId);
		return true;
	}

	@Override
	public boolean exists(Group group) {
		Resource resource = getGroupResource(group.getParentId());
		if (resource == null) {
			return getGroupResource(group.getType(), group.getName()).exists();
		}
		return resource.getDirectory(group.getName()).exists();
	}

	@Override
	public boolean containsApiGroup(String groupId) {
		return "0".equals(groupId) || cacheApiTree.containsKey(groupId);
	}

	@Override
	public Group readGroup(Resource resource) {
		return JsonUtils.readValue(resource.read(), Group.class);
	}

	@Override
	public TreeNode apiGroupTree() {
		List groups = groupList(Constants.GROUP_TYPE_API);
		cacheApiTree = groups.stream().collect(Collectors.toMap(Group::getId, value -> value));
		clearMappings();
		return convertToTree(groups);
	}

	private void clearMappings(){
		Set apiGroups = cacheApiTree.keySet();
		Set functionGroups = cacheFunctionTree.keySet();
		mappings.entrySet().removeIf(entry -> !apiGroups.contains(entry.getKey()) && !functionGroups.contains(entry.getKey()));
	}

	@Override
	public TreeNode functionGroupTree() {
		List groups = groupList(Constants.GROUP_TYPE_FUNCTION);
		cacheFunctionTree = groups.stream().collect(Collectors.toMap(Group::getId, value -> value));
		clearMappings();
		return convertToTree(groups);
	}

	@Override
	public List groupList(String type) {
		Resource resource = this.workspace.getDirectory(Constants.GROUP_TYPE_API.equals(type) ? Constants.PATH_API : Constants.PATH_FUNCTION);
		resource.readAll();
		return getGroupList(resource);
	}

	private List getGroupList(Resource resource){
		return resource.dirs().stream().map(it -> it.getResource(Constants.GROUP_METABASE)).filter(Resource::exists)
				.map(it -> {
					Group group = JsonUtils.readValue(it.read(), Group.class);
					mappings.put(group.getId(), it);
					return group;
				})
				.collect(Collectors.toList());
	}

	@Override
	public List cachedGroupList(String type) {
		Resource resource = this.workspace.getDirectory(Constants.GROUP_TYPE_API.equals(type) ? Constants.PATH_API : Constants.PATH_FUNCTION);
		return getGroupList(resource);
	}

	@Override
	public String getFullPath(String groupId) {
		StringBuilder path = new StringBuilder();
		Group group;
		while ((group = cacheFunctionTree.getOrDefault(groupId, cacheApiTree.get(groupId))) != null) {
			path.insert(0, '/' + Objects.toString(group.getPath(), ""));
			groupId = group.getParentId();
		}
		// 需要找到根节点，否则说明中间被删除了
		if (!"0".equals(groupId)) {
			return null;
		}
		return PathUtils.replaceSlash(path.toString());
	}

	@Override
	public String getFullName(String groupId) {
		if (groupId == null || "0".equals(groupId)) {
			return "";
		}
		StringBuilder name = new StringBuilder();
		Group group;
		while ((group = cacheFunctionTree.getOrDefault(groupId, cacheApiTree.get(groupId))) != null) {
			name.insert(0, '/' + group.getName());
			groupId = group.getParentId();
		}
		// 需要找到根节点，否则说明中间被删除了
		if (!"0".equals(groupId)) {
			return null;
		}
		return name.substring(1);
	}

	@Override
	public Resource getGroupResource(String groupId) {
		if (groupId == null || "0".equals(groupId)) {
			return null;
		}
		Resource resource = mappings.get(groupId);
		return resource == null ? null : resource.parent();
	}

	@Override
	public List getGroupsWithoutGroups(List groupIds) {
		return this.mappings.keySet().stream().filter(groupId -> !groupIds.contains(groupId)).collect(Collectors.toList());
	}

	private TreeNode convertToTree(List groups) {
		TreeNode root = new TreeNode<>();
		root.setNode(new Group("0", "root"));
		convertToTree(groups, root);
		return root;
	}

	private void convertToTree(List remains, TreeNode current) {
		Group temp;
		List> childNodes = new LinkedList<>();
		Iterator iterator = remains.iterator();
		while (iterator.hasNext()) {
			temp = iterator.next();
			if (current.getNode().getId().equals(temp.getParentId())) {
				childNodes.add(new TreeNode<>(temp));
				iterator.remove();
			}
		}
		current.setChildren(childNodes);
		childNodes.forEach(it -> convertToTree(remains, it));
	}
}