Skip to content

T
tagManager
Commit 367267a8 by lanmw
Options

deleteTag

parent e2de8df7
Showing with 136 additions and 170 deletions
src/main/java/com/keymobile/tagmanager/api/TagCtrl.java
package com.keymobile.tagmanager.api;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.keymobile.tagmanager.model.Page;
import com.keymobile.tagmanager.model.Tag;
import com.keymobile.tagmanager.service.TagService;
import com.keymobile.tagmanager.util.Constants;
import com.keymobile.tagmanager.util.JsonTreeHelper.JsonNode;
import com.keymobile.tagmanager.util.UserInfoUtils;
......@@ -32,36 +31,49 @@ public class TagCtrl {
@RequestBody Tag tag) throws Exception {
String userName = UserInfoUtils.getUserName();
tag.setCreator(userName);
return tagService.addOrUpdateTag(parentId, tag);
return tagService.addOrUpdateTag(parentId, tag, userName);
}
@ApiOperation(value = "删除标签", notes = "删除标签")
@PostMapping(value = "/deleteTag")
public void deleteTag(@RequestParam(value = "tagId") String tagId) throws Exception {
String userName = UserInfoUtils.getUserName();
tagService.deleteTag(tagId, userName);
}
@ApiOperation(value = "存在节点", notes = "存在节点")
@GetMapping(value = "/hasChild")
public boolean hasChild(@RequestParam(value = "tagId") String tagId) throws Exception {
String userName = UserInfoUtils.getUserName();
return tagService.hasChild(tagId, userName);
}
// @PreAuthorize("principal.authorities.?[authority.startsWith('ROLE_tagmanager_admin')].size() > 0")
@ApiOperation(value = "查询系统标签树", notes = "查询系统标签树")
@PostMapping(value = "/querySystemTagAsTree")
@GetMapping(value = "/querySystemTagAsTree")
public JsonNode[] querySystemTagAsTree(@RequestParam(value = "parentId", required = false) String parentId) throws Exception {
String userName = UserInfoUtils.getUserName();
return tagService.queryTagAsTreeByTagType(Constants.TAG_SYSTEM_TYPE, parentId, userName);
return tagService.querySystemTagAsTree(parentId);
}
@ApiOperation(value = "查询个人标签树", notes = "查询个人标签树")
@PostMapping(value = "/queryPersonalTagAsTree")
@GetMapping(value = "/queryPersonalTagAsTree")
public JsonNode[] queryPersonalTagAsTree(@RequestParam(value = "parentId", required = false) String parentId) throws Exception {
String userName = UserInfoUtils.getUserName();
return tagService.queryTagAsTreeByTagType(Constants.TAG_PERSONAL_TYPE, parentId, userName);
return tagService.queryPersonalTagAsTree(parentId, userName);
}
@ApiOperation(value = "搜索系統标签", notes = "搜索系統标签")
@PostMapping(value = "/searchSystemTagByPage")
@GetMapping(value = "/searchSystemTagByPage")
public Page searchSystemTagByPage(@RequestParam(required = false, value = "keyword") String keyword,
@RequestParam(required = false, value = "domain") Integer domain,
@RequestParam("pageNo") Integer pageNo,
@RequestParam("pageSize") Integer pageSize) throws Exception {
String userName = UserInfoUtils.getUserName();
return tagService.searchSystemTagByPage(userName, keyword, domain, new Page(pageSize, pageNo));
return tagService.searchSystemTagByPage(keyword, domain, new Page(pageSize, pageNo));
}
@ApiOperation(value = "搜索个人标签", notes = "搜索个人标签")
@PostMapping(value = "/searchPersonalTagByPage")
@GetMapping(value = "/searchPersonalTagByPage")
public Page searchPersonalTagByPage(@RequestParam(required = false, value = "keyword") String keyword,
@RequestParam(required = false , value = "domain") Integer domain,
@RequestParam("pageNo") Integer pageNo,
......
src/main/java/com/keymobile/tagmanager/service/TagService.java
package com.keymobile.tagmanager.service;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import org.bson.Document;
import org.bson.types.ObjectId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
......@@ -18,11 +15,8 @@ import org.springframework.data.domain.Sort.Order;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.gridfs.GridFsTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import org.springframework.web.multipart.MultipartFile;
import com.keymobile.tagmanager.exception.TagDuplicateException;
import com.keymobile.tagmanager.exception.TagException;
import com.keymobile.tagmanager.exception.TagNotExistException;
......@@ -39,71 +33,60 @@ public class TagService {
@Autowired
private MongoOperations mongoOperations;
@Autowired
private GridFsTemplate gridFsTemplate;
@Autowired
private TagRepository tagRepository;
private Logger logger = LoggerFactory.getLogger(TagService.class);
public Tag addOrUpdateTag(Tag tag, MultipartFile file) throws Exception {
checkTagValid(tag);
public Tag addOrUpdateTag(String parentId, Tag tag, String userName) throws TagNotExistException, TagDuplicateException, TagException {
tag.setPath(tag.getName());
if (!StringUtils.isEmpty(parentId)) {
Tag parent = getTagById(parentId);
tag.setPath(parent.getPath() + Constants.TAG_PATH_SEPARATOR + tag.getName());
}
checkTagValid(tag, userName);
if (!StringUtils.isEmpty(tag.getId())) {
Tag origin = mongoOperations.findOne(Query.query(Criteria.where("_id").is(tag.getId())), Tag.class);
List<Tag> relationTags = mongoOperations.find(
Query.query(Criteria.where("path").regex("^" + origin.getPath() + Constants.TAG_PATH_SEPARATOR)),
Tag.class);
Query.query(Criteria.where("path").regex("^" + origin.getPath() + Constants.TAG_PATH_SEPARATOR)
.and("creator").is(userName)), Tag.class);
relationTags.forEach(p -> {
p.setPath(p.getPath().replaceAll(origin.getPath(), tag.getPath()));
});
tagRepository.saveAll(relationTags);
if (!StringUtils.isEmpty(file)) {
removeFileInMongoDB(Arrays.asList(origin.getImgId()));
}
}
if (!StringUtils.isEmpty(file)) {
String fileId = saveFileInMongoDB(file);
tag.setImgId(fileId);
}
tag.setLevel(tag.getPath().split(",").length);
return tagRepository.save(tag);
}
public void removeFileInMongoDB(List<String> fileIds) {
gridFsTemplate.delete(Query.query(Criteria.where("_id").in(fileIds)));
public Tag getTagById(String tagId) throws TagNotExistException {
Tag t = mongoOperations.findOne(Query.query(Criteria.where("_id").is(tagId)), Tag.class);
if (t == null)
throw new TagNotExistException("ID=[" + tagId + "] tag not exist!");
return t;
}
public String saveFileInMongoDB(MultipartFile file) throws Exception {
ObjectId gridFSFile = gridFsTemplate.store(file.getInputStream(), file.getOriginalFilename(),
file.getContentType());
return gridFSFile.toString();
}
private void checkTagValid(Tag tag) throws TagDuplicateException, TagException {
private void checkTagValid(Tag tag, String userName) throws TagDuplicateException, TagException {
if (!Constants.TAG_PERSONAL_TYPE.equals(tag.getTagType())
&& !Constants.TAG_SYSTEM_TYPE.equals(tag.getTagType())) {
throw new TagException(String.format("No such tagType %s", tag.getTagType()));
}
Tag t = mongoOperations.findOne(Query.query(Criteria.where("path").is(tag.getPath())), Tag.class);
Tag t = mongoOperations.findOne(Query.query(Criteria.where("path").is(tag.getPath())
.and("creator").is(userName)), Tag.class);
if (t != null && !t.getId().equals(tag.getId()))
throw new TagDuplicateException("tag [" + tag.getName() + "] is already exist in target!");
}
public JsonNode[] querySubTagAsTree(String dirId) {
public JsonNode[] queryPersonalTagAsTree(String parentId, String userName) throws TagNotExistException {
List<Tag> tags = new ArrayList<>();
List<Order> orders = new ArrayList<>();
orders.add(new Order(Direction.ASC, "level"));
orders.add(new Order(Direction.DESC, "order"));
if (StringUtils.isEmpty(dirId)) {
tags = mongoOperations.find(new Query().with(Sort.by(orders)), Tag.class);
if (StringUtils.isEmpty(parentId)) {
tags = mongoOperations.find(createPersonalTagQuery(userName), Tag.class);
} else {
Tag t = mongoOperations.findOne(Query.query(Criteria.where("_id").is(dirId)), Tag.class);
tags = getSubTagByParentDir(t);
tags.forEach(d -> d.setPath(d.getPath().replaceAll(t.getPath(), t.getName())));
Tag parentTag = getTagById(parentId);
tags = getPersonSubTag(parentTag, userName);
tags.forEach(tag -> tag.setPath(tag.getPath().replaceAll(parentTag.getPath(), parentTag.getName())));
}
List<JsonNode> nodes = new ArrayList<>();
tags.forEach(p -> {
......@@ -117,91 +100,66 @@ public class TagService {
return new JsonNode[] {};
}
public int deleteTags(List<String> tagIds) {
int success = 0;
List<Tag> tags = mongoOperations.find(Query.query(Criteria.where("_id").in(tagIds)), Tag.class);
for (Tag t : tags) {
try {
List<Tag> subTags = getSubTagByParentDir(t);
List<String> subTagIds = subTags.stream().map(subTag -> subTag.getId()).collect(Collectors.toList());
List<String> subTagImgIds = subTags.stream().map(subTag -> subTag.getImgId())
.collect(Collectors.toList());
removeFileInMongoDB(subTagImgIds);
mongoOperations.findAllAndRemove(Query.query(Criteria.where("_id").in(subTagIds)), Tag.class);
success++;
} catch (Exception e) {
logger.error("deleteTag error.", e);
}
}
return success;
private Query createPersonalTagQuery(String userName) {
return Query.query(Criteria.where("tagType").is(Constants.TAG_PERSONAL_TYPE)
.orOperator(
Criteria.where("isOpen").is(Constants.TAG_OPEN_STATUS),
Criteria.where("creator").is(userName)))
.with(Sort.by(getDefaultTagOrders()));
}
private List<Tag> getSubTagByParentDir(Tag parentTag) {
private List<Order> getDefaultTagOrders() {
List<Order> orders = new ArrayList<>();
orders.add(new Order(Direction.ASC, "level"));
orders.add(new Order(Direction.DESC, "order"));
List<Tag> dirs = mongoOperations.find(new Query()
.addCriteria(Criteria.where("path").regex("^" + parentTag.getPath() + Constants.TAG_PATH_SEPARATOR))
.with(Sort.by(orders)), Tag.class);
return orders;
}
public List<Tag> getPersonSubTag(Tag parentTag, String userName) {
List<Tag> dirs = mongoOperations.find(new Query().addCriteria(Criteria.where("path")
.regex("^"+parentTag.getPath() + Constants.TAG_PATH_SEPARATOR)
.and("tagType").is(Constants.TAG_PERSONAL_TYPE)
.orOperator(
Criteria.where("openStatus").is(Constants.TAG_OPEN_STATUS),
Criteria.where("creator").is(userName)))
.with(Sort.by(getDefaultTagOrders())), Tag.class);
dirs.add(parentTag);
return dirs;
}
public Tag getTagById(String tagId) throws TagNotExistException {
Tag t = mongoOperations.findOne(Query.query(Criteria.where("_id").is(tagId)), Tag.class);
if (t == null)
throw new TagNotExistException("ID=[" + tagId + "] tag not exist!");
return t;
}
public boolean checkDirExistTags(String dirId) {
Tag origin = mongoOperations.findOne(Query.query(Criteria.where("_id").is(dirId)), Tag.class);
List<Tag> relationTags = mongoOperations.find(
Query.query(Criteria.where("path")
.regex("^" + origin.getPath() + Constants.TAG_PATH_SEPARATOR)
.and("level").is(origin.getLevel() + 1)),
Tag.class);
for (Tag childTag : relationTags) {
if (childTag.getTagType().equals(Constants.TAG_PERSONAL_TYPE))
return true;
}
return false;
public Page searchPersonalTagByPage(String userName, String keyword, Integer domain, Page page) {
Query q = createPersonalTagQuery(userName);
if (org.apache.commons.lang.StringUtils.isNotBlank(keyword) && !"*".equals(keyword)) {
Criteria c = new Criteria();
c.orOperator(createRegexQuery(Arrays.asList("name", "nameEn", "desc"), keyword));
q.addCriteria(c);
}
q.skip(page.getOffset());
q.limit(page.getPageSize());
List<Tag> tags = mongoOperations
.find(q, Tag.class);
long count = mongoOperations.count(q, Tag.class);
page.setData(tags);
page.setTotal(count);
return page;
public Tag addOrUpdateTag(String parentId, Tag tag) throws TagNotExistException, TagDuplicateException, TagException {
tag.setPath(tag.getName());
if (!StringUtils.isEmpty(parentId) && StringUtils.isEmpty(tag.getId())) {
Tag parent = getTagById(parentId);
tag.setPath(parent.getPath() + Constants.TAG_PATH_SEPARATOR + tag.getName());
}
checkTagValid(tag);
if (!StringUtils.isEmpty(tag.getId())) {
Tag origin = mongoOperations.findOne(Query.query(Criteria.where("_id").is(tag.getId())), Tag.class);
List<Tag> relationTags = mongoOperations.find(
Query.query(Criteria.where("path").regex("^" + origin.getPath() + Constants.TAG_PATH_SEPARATOR)),
Tag.class);
relationTags.forEach(p -> {
p.setPath(p.getPath().replaceAll(origin.getPath(), tag.getPath()));
});
tagRepository.saveAll(relationTags);
}
tag.setLevel(tag.getPath().split(",").length);
return tagRepository.save(tag);
private Criteria[] createRegexQuery(List<String> asList, String keyword) {
return asList.stream().map(col -> {
return Criteria.where(col).regex(keyword, "i");
}).collect(Collectors.toList()).toArray(new Criteria[0]);
}
public JsonNode[] queryTagAsTreeByTagType(String tagType, String parentId, String userName) throws TagNotExistException {
public JsonNode[] querySystemTagAsTree(String parentId) throws TagNotExistException {
List<Tag> tags = new ArrayList<>();
if (StringUtils.isEmpty(parentId)) {
tags = mongoOperations.find(Query.query(Criteria
.where("tagType").is(tagType)
.orOperator(
Criteria.where("openStatus").is(Constants.TAG_OPEN_STATUS),
Criteria.where("creator").is(userName)))
.with(Sort.by(getDefaultTagOrders())), Tag.class);
.where("tagType").is(Constants.TAG_SYSTEM_TYPE)).with(Sort.by(getDefaultTagOrders())), Tag.class);
} else {
Tag parentTag = getTagById(parentId);
tags = getSubDirByParentDir(parentTag, tagType, userName);
tags = getSystemSubTag(parentTag);
tags.forEach(tag -> tag.setPath(tag.getPath().replaceAll(parentTag.getPath(), parentTag.getName())));
}
List<JsonNode> nodes = new ArrayList<>();
......@@ -216,71 +174,53 @@ public class TagService {
return new JsonNode[] {};
}
private List<Order> getDefaultTagOrders() {
List<Order> orders = new ArrayList<>();
orders.add(new Order(Direction.ASC, "level"));
orders.add(new Order(Direction.DESC, "order"));
return orders;
public Page searchSystemTagByPage(String keyword, Integer domain, Page page) {
Map<String, Object> condition = new HashMap<>();
if (org.apache.commons.lang.StringUtils.isNotBlank(keyword) && !"*".equals(keyword)) {
MongoOperationsUtil.addSearchCriteria(Arrays.asList("name", "nameEn", "desc"), keyword, condition);
}
condition.put("tagType", Constants.TAG_SYSTEM_TYPE);
Query q = MongoOperationsUtil.createQueryWithSpecifiedField(condition, page, getDefaultTagOrders());
List<Tag> tags = mongoOperations.find(q, Tag.class);
long count = mongoOperations.count(q, Tag.class);
page.setData(tags);
page.setTotal(count);
return page;
}
public List<Tag> getSubDirByParentDir(Tag parentTag, String tagType, String userName) {
private List<Tag> getSystemSubTag(Tag parentTag) {
List<Tag> dirs = mongoOperations.find(new Query().addCriteria(Criteria.where("path")
.regex("^"+parentTag.getPath() + Constants.TAG_PATH_SEPARATOR)
.and("tagType").is(tagType)
.orOperator(
Criteria.where("openStatus").is(Constants.TAG_OPEN_STATUS),
Criteria.where("creator").is(userName)))
.and("tagType").is(Constants.TAG_SYSTEM_TYPE))
.with(Sort.by(getDefaultTagOrders())), Tag.class);
dirs.add(parentTag);
return dirs;
}
public Page searchPersonalTagByPage(String userName, String keyword, Integer domain,
com.keymobile.tagmanager.model.Page page) {
Map<String, Object> or1 = new HashMap<>();
Map<String, Object> or2 = new HashMap<>();
if (org.apache.commons.lang.StringUtils.isNotBlank(keyword) && !"*".equals(keyword)) {
MongoOperationsUtil.addSearchCriteria(Arrays.asList("name", "nameEn", "desc"), keyword, or1);
MongoOperationsUtil.addSearchCriteria(Arrays.asList("name", "nameEn", "desc"), keyword, or2);
public void deleteTag(String tagId, String userName) throws TagException {
Optional<Tag> optional = tagRepository.findById(tagId);
if (optional.isPresent()) {
Tag parentTag = optional.get();
List<Tag> childs = mongoOperations.find(Query.query(Criteria.where("path")
.regex("^"+parentTag.getPath() + Constants.TAG_PATH_SEPARATOR)
.and("creator").is(userName)), Tag.class);
if (!childs.isEmpty()) {
throw new TagException("存在子节点，不允许删除！");
}
or1.put("tagType", Constants.TAG_PERSONAL_TYPE);
or1.put("creator", userName);
or2.put("tagType", Constants.TAG_PERSONAL_TYPE);
or2.put("openStatus", Constants.TAG_OPEN_STATUS);
Map<String, Object> condition = new HashMap<>();
condition.put("$or", Arrays.asList(or1, or2));
Query q = MongoOperationsUtil.createQueryWithSpecifiedField(condition,
Arrays.asList("name", "nameEN", "isOpen", "creator", "desc"),
page, Arrays.asList(new Order(Direction.ASC, "name")));
List<Tag> tags = mongoOperations
.find(q, Tag.class);
long count = mongoOperations.count(q, Tag.class);
page.setData(tags);
page.setTotal(count);
return page;
tagRepository.deleteById(tagId);
}
public Page searchSystemTagByPage(String userName, String keyword, Integer domain, Page page) {
Map<String, Object> condition = new HashMap<>();
if (org.apache.commons.lang.StringUtils.isNotBlank(keyword) && !"*".equals(keyword)) {
MongoOperationsUtil.addSearchCriteria(Arrays.asList("name", "nameEn", "desc"), keyword, condition);
}
condition.put("tagType", Constants.TAG_SYSTEM_TYPE);
Query q = MongoOperationsUtil.createQueryWithSpecifiedField(condition,
Arrays.asList("name", "nameEN", "isOpen", "creator", "desc"),
page, Arrays.asList(new Order(Direction.ASC, "name")));
List<Tag> tags = mongoOperations
.find(q, Tag.class);
long count = mongoOperations.count(q, Tag.class);
page.setData(tags);
page.setTotal(count);
return page;
public boolean hasChild(String tagId, String userName) throws TagException {
Optional<Tag> optional = tagRepository.findById(tagId);
if (optional.isPresent()) {
Tag parentTag = optional.get();
List<Tag> childs = mongoOperations.find(Query.query(Criteria.where("path")
.regex("^"+parentTag.getPath() + Constants.TAG_PATH_SEPARATOR)
.and("creator").is(userName)), Tag.class);
return !childs.isEmpty();
}
return false;
}
}
src/main/java/com/keymobile/tagmanager/util/MongoOperationsUtil.java
......@@ -59,6 +59,20 @@ public class MongoOperationsUtil {
return q;
}
public static Query createQueryWithSpecifiedField(Map<String, Object> condition, Page page, List<Order> orderList) {
Document dbObject = new Document();
condition.forEach((k, v) -> {
dbObject.put(k, v);
});
Query q = new BasicQuery(dbObject);
q.skip(page.getOffset());
q.limit(page.getPageSize());
if (orderList != null && !orderList.isEmpty()) {
q.with(Sort.by(orderList));
}
return q;
}
public static Query createQueryWithSpecifiedField(List<String> specifields) {
Map<String, Object> condition = new HashMap<>();
return createQueryWithSpecifiedField(condition, specifields);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment