7x31/databasir
1
0
Fork 0
mirror of https://github.com/vran-dev/databasir.git synced 2025-08-08 17:32:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

change remark to discussion model & bug fix (#45)

Browse Source 
* feat: change remark to discussion

* feat: change remark model to discussion model

* fix: sync duplicate column

* feat:update frontend resources

* fix: checkstyle
This commit is contained in:
vran
2022-03-13 09:46:44 +08:00
committed by GitHub
parent f026d406a2
commit e85e0e6e70
52 changed files with 604 additions and 481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/src/main/java/com/databasir/core/domain/database/converter/DatabaseTypePojoConverter.java
View File

@@ -6,10 +6,14 @@ import com.databasir.core.domain.database.data.DatabaseTypePageResponse;
import com.databasir.core.domain.database.data.DatabaseTypeUpdateRequest;
import com.databasir.dao.tables.pojos.DatabaseTypePojo;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
@Mapper(componentModel = "spring")
public interface DatabaseTypePojoConverter {
@Mapping(target = "id", ignore = true)
@Mapping(target = "updateAt", ignore = true)
@Mapping(target = "createAt", ignore = true)
DatabaseTypePojo of(DatabaseTypeCreateRequest request);
DatabaseTypePojo of(DatabaseTypeUpdateRequest request);

27
core/src/main/java/com/databasir/core/domain/document/converter/DocumentResponseConverter.java
View File

@@ -8,6 +8,8 @@ import org.mapstruct.Mapping;
import org.mapstruct.ReportingPolicy;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Mapper(componentModel = "spring", uses = JsonConverter.class, unmappedTargetPolicy = ReportingPolicy.WARN)
public interface DocumentResponseConverter {
@@ -20,6 +22,31 @@ public interface DocumentResponseConverter {
List<TableIndexDocumentPojo> indexes,
List<TableTriggerDocumentPojo> triggers);
@Mapping(target = "columns", source = "columns")
@Mapping(target = "indexes", source = "indexes")
@Mapping(target = "triggers", source = "triggers")
@SuppressWarnings("checkstyle:all")
DatabaseDocumentResponse.TableDocumentResponse of(TableDocumentPojo tableDocument,
Integer discussionCount,
List<DatabaseDocumentResponse.TableDocumentResponse.ColumnDocumentResponse> columns,
List<TableIndexDocumentPojo> indexes,
List<TableTriggerDocumentPojo> triggers);
DatabaseDocumentResponse.TableDocumentResponse.ColumnDocumentResponse of(TableColumnDocumentPojo pojo,
Integer discussionCount);
default List<DatabaseDocumentResponse.TableDocumentResponse.ColumnDocumentResponse> of(
List<TableColumnDocumentPojo> columns,
String tableName,
Map<String, Integer> discussionCountMapByJoinName) {
return columns.stream()
.map(column -> {
Integer count = discussionCountMapByJoinName.get(tableName + "." + column.getName());
return of(column, count);
})
.collect(Collectors.toList());
}
@Mapping(target = "columnNames", source = "columnNameArray")
DatabaseDocumentResponse.TableDocumentResponse.IndexDocumentResponse of(TableIndexDocumentPojo indexDocument);

16
core/src/main/java/com/databasir/core/domain/document/converter/DocumentSimpleResponseConverter.java
View File

@@ -9,6 +9,8 @@ import org.mapstruct.Mapping;
import org.mapstruct.ReportingPolicy;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Mapper(componentModel = "spring", uses = JsonConverter.class, unmappedTargetPolicy = ReportingPolicy.WARN)
public interface DocumentSimpleResponseConverter {
@@ -17,5 +19,17 @@ public interface DocumentSimpleResponseConverter {
@Mapping(target = "createAt", source = "databaseDocument.createAt")
@Mapping(target = "documentVersion", source = "databaseDocument.version")
DatabaseDocumentSimpleResponse of(DatabaseDocumentPojo databaseDocument,
List<TableDocumentPojo> tables);
List<DatabaseDocumentSimpleResponse.TableData> tables);
DatabaseDocumentSimpleResponse.TableData of(TableDocumentPojo tables, Integer discussionCount);
default List<DatabaseDocumentSimpleResponse.TableData> of(List<TableDocumentPojo> tables,
Map<String, Integer> discussionCountMapByTableName) {
return tables.stream()
.map(table -> {
Integer count = discussionCountMapByTableName.get(table.getName());
return of(table, count);
})
.collect(Collectors.toList());
}
}

4
core/src/main/java/com/databasir/core/domain/document/data/DatabaseDocumentResponse.java
View File

@@ -46,6 +46,8 @@ public class DatabaseDocumentResponse {
private String comment;
private Integer discussionCount;
@Builder.Default
private List<ColumnDocumentResponse> columns = new ArrayList<>();
@@ -82,6 +84,8 @@ public class DatabaseDocumentResponse {
private String defaultValue;
private Integer discussionCount;
private LocalDateTime createAt;
}

2
core/src/main/java/com/databasir/core/domain/document/data/DatabaseDocumentSimpleResponse.java
View File

@@ -35,5 +35,7 @@ public class DatabaseDocumentSimpleResponse {
private String type;
private String comment;
private Integer discussionCount;
}
}

43
core/src/main/java/com/databasir/core/domain/document/service/DocumentService.java
View File

@@ -15,8 +15,10 @@ import com.databasir.core.meta.data.DatabaseMeta;
import com.databasir.core.render.markdown.MarkdownBuilder;
import com.databasir.dao.impl.*;
import com.databasir.dao.tables.pojos.*;
import com.databasir.dao.value.DocumentDiscussionCountPojo;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.jooq.tools.StringUtils;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
@@ -55,6 +57,8 @@ public class DocumentService {
private final TableTriggerDocumentDao tableTriggerDocumentDao;
private final DocumentDiscussionDao documentDiscussionDao;
private final DocumentPojoConverter documentPojoConverter;
private final DocumentResponseConverter documentResponseConverter;
@@ -129,21 +133,22 @@ public class DocumentService {
}
public Optional<DatabaseDocumentSimpleResponse> getSimpleOneByProjectId(Integer projectId, Long version) {
Optional<DatabaseDocumentPojo> documentOption;
if (version == null) {
return databaseDocumentDao.selectNotArchivedByProjectId(projectId)
.map(document -> {
Integer id = document.getId();
var tables = tableDocumentDao.selectByDatabaseDocumentId(id);
return documentSimpleResponseConverter.of(document, tables);
});
documentOption = databaseDocumentDao.selectNotArchivedByProjectId(projectId);
} else {
return databaseDocumentDao.selectOptionalByProjectIdAndVersion(projectId, version)
.map(document -> {
Integer id = document.getId();
var tables = tableDocumentDao.selectByDatabaseDocumentId(id);
return documentSimpleResponseConverter.of(document, tables);
});
documentOption = databaseDocumentDao.selectOptionalByProjectIdAndVersion(projectId, version);
}
return documentOption.map(document -> {
Integer id = document.getId();
var tables = tableDocumentDao.selectByDatabaseDocumentId(id);
var discussionCountMapByTableName =
documentDiscussionDao.selectTableDiscussionCount(projectId)
.stream()
.collect(Collectors.toMap(d -> d.getTableName(), d -> d.getCount(), (a, b) -> a));
var tableMetas = documentSimpleResponseConverter.of(tables, discussionCountMapByTableName);
return documentSimpleResponseConverter.of(document, tableMetas);
});
}
public Optional<DatabaseDocumentResponse> getOneByProjectId(Integer projectId, Long version) {
@@ -207,19 +212,31 @@ public class DocumentService {
tableIndexDocumentDao.selectByDatabaseDocumentIdAndIdIn(databaseDocumentId, tableIds);
var triggers =
tableTriggerDocumentDao.selectByDatabaseDocumentIdAndIdIn(databaseDocumentId, tableIds);
var discussions = documentDiscussionDao.selectAllDiscussionCount(projectId);
Map<Integer, List<TableColumnDocumentPojo>> columnsGroupByTableMetaId = columns.stream()
.collect(Collectors.groupingBy(TableColumnDocumentPojo::getTableDocumentId));
Map<Integer, List<TableIndexDocumentPojo>> indexesGroupByTableMetaId = indexes.stream()
.collect(Collectors.groupingBy(TableIndexDocumentPojo::getTableDocumentId));
Map<Integer, List<TableTriggerDocumentPojo>> triggersGroupByTableMetaId = triggers.stream()
.collect(Collectors.groupingBy(TableTriggerDocumentPojo::getTableDocumentId));
Map<String, Integer> discussionCountMapByJoinName = discussions.stream()
.collect(Collectors.toMap(
d -> String.join(".",
d.getTableName(),
StringUtils.defaultIfBlank(d.getColumnName(), "")),
DocumentDiscussionCountPojo::getCount,
(a, b) -> a));
return tables.stream()
.map(table -> {
Integer tableId = table.getId();
var subColumns = columnsGroupByTableMetaId.getOrDefault(tableId, Collections.emptyList());
var subIndexes = indexesGroupByTableMetaId.getOrDefault(tableId, Collections.emptyList());
var subTriggers = triggersGroupByTableMetaId.getOrDefault(tableId, Collections.emptyList());
return documentResponseConverter.of(table, subColumns, subIndexes, subTriggers);
var discussionCount = discussionCountMapByJoinName.get(table.getName());
var columnResponses =
documentResponseConverter.of(subColumns, table.getName(), discussionCountMapByJoinName);
return documentResponseConverter.of(table, discussionCount, columnResponses, subIndexes,
subTriggers);
})
.collect(Collectors.toList());
}

17
core/src/main/java/com/databasir/core/domain/remark/converter/DiscussionResponseConverter.java Normal file
View File

@@ -0,0 +1,17 @@
package com.databasir.core.domain.remark.converter;
import com.databasir.core.domain.remark.data.DiscussionResponse;
import com.databasir.dao.tables.pojos.DocumentDiscussionPojo;
import com.databasir.dao.tables.pojos.UserPojo;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
@Mapper(componentModel = "spring")
public interface DiscussionResponseConverter {
@Mapping(target = "id", source = "discussion.id")
@Mapping(target = "createAt", source = "discussion.createAt")
@Mapping(target = "content", source = "discussion.content")
DiscussionResponse of(DocumentDiscussionPojo discussion,
UserPojo discussBy);
}

19
core/src/main/java/com/databasir/core/domain/remark/converter/RemarkResponseConverter.java
View File

@@ -1,19 +0,0 @@
package com.databasir.core.domain.remark.converter;
import com.databasir.core.domain.remark.data.RemarkResponse;
import com.databasir.dao.tables.pojos.DocumentRemarkPojo;
import com.databasir.dao.tables.pojos.UserPojo;
import org.mapstruct.Mapper;
import org.mapstruct.Mapping;
@Mapper(componentModel = "spring")
public interface RemarkResponseConverter {
@Mapping(target = "remarkBy.userId", source = "remarkBy.id")
@Mapping(target = "remarkBy.nickname", source = "remarkBy.nickname")
@Mapping(target = "remarkBy.email", source = "remarkBy.email")
@Mapping(target = "id", source = "remark.id")
@Mapping(target = "createAt", source = "remark.createAt")
RemarkResponse of(DocumentRemarkPojo remark,
UserPojo remarkBy);
}

4
core/src/main/java/com/databasir/core/domain/remark/data/RemarkCreateRequest.java → core/src/main/java/com/databasir/core/domain/remark/data/DiscussionCreateRequest.java
View File

@@ -6,10 +6,10 @@ import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
@Data
public class RemarkCreateRequest {
public class DiscussionCreateRequest {
@NotBlank
private String remark;
private String content;
@NotNull
private String tableName;

10
core/src/main/java/com/databasir/core/domain/remark/data/RemarkListCondition.java → core/src/main/java/com/databasir/core/domain/remark/data/DiscussionListCondition.java
View File

@@ -10,7 +10,7 @@ import java.util.ArrayList;
import java.util.List;
@Data
public class RemarkListCondition {
public class DiscussionListCondition {
@NotBlank
private String tableName;
@@ -19,17 +19,17 @@ public class RemarkListCondition {
public Condition toCondition(Integer projectId) {
List<Condition> conditions = new ArrayList<>();
Condition condition = Tables.DOCUMENT_REMARK.TABLE_NAME.eq(tableName);
Condition condition = Tables.DOCUMENT_DISCUSSION.TABLE_NAME.eq(tableName);
conditions.add(condition);
Condition columnCondition;
if (columnName != null) {
columnCondition = Tables.DOCUMENT_REMARK.COLUMN_NAME.eq(columnName);
columnCondition = Tables.DOCUMENT_DISCUSSION.COLUMN_NAME.eq(columnName);
} else {
columnCondition = Tables.DOCUMENT_REMARK.COLUMN_NAME.isNull();
columnCondition = Tables.DOCUMENT_DISCUSSION.COLUMN_NAME.isNull();
}
conditions.add(columnCondition);
conditions.add(Tables.DOCUMENT_REMARK.PROJECT_ID.eq(projectId));
conditions.add(Tables.DOCUMENT_DISCUSSION.PROJECT_ID.eq(projectId));
return conditions.stream().reduce(Condition::and).orElse(DSL.trueCondition());
}
}

8
core/src/main/java/com/databasir/core/domain/remark/data/RemarkResponse.java → core/src/main/java/com/databasir/core/domain/remark/data/DiscussionResponse.java
View File

@@ -5,20 +5,20 @@ import lombok.Data;
import java.time.LocalDateTime;
@Data
public class RemarkResponse {
public class DiscussionResponse {
private Integer id;
private Integer projectId;
private String remark;
private String content;
private RemarkUser remarkBy;
private DiscussByUser discussBy;
private LocalDateTime createAt;
@Data
public static class RemarkUser {
public static class DiscussByUser {
private Integer userId;

49
core/src/main/java/com/databasir/core/domain/remark/service/DocumentRemarkService.java → core/src/main/java/com/databasir/core/domain/remark/service/DocumentDiscussionService.java
View File

@@ -1,14 +1,14 @@
package com.databasir.core.domain.remark.service;
import com.databasir.common.exception.Forbidden;
import com.databasir.core.domain.remark.converter.RemarkResponseConverter;
import com.databasir.core.domain.remark.data.RemarkCreateRequest;
import com.databasir.core.domain.remark.data.RemarkListCondition;
import com.databasir.core.domain.remark.data.RemarkResponse;
import com.databasir.dao.impl.DocumentRemarkDao;
import com.databasir.core.domain.remark.converter.DiscussionResponseConverter;
import com.databasir.core.domain.remark.data.DiscussionCreateRequest;
import com.databasir.core.domain.remark.data.DiscussionListCondition;
import com.databasir.core.domain.remark.data.DiscussionResponse;
import com.databasir.dao.impl.DocumentDiscussionDao;
import com.databasir.dao.impl.ProjectDao;
import com.databasir.dao.impl.UserDao;
import com.databasir.dao.tables.pojos.DocumentRemarkPojo;
import com.databasir.dao.tables.pojos.DocumentDiscussionPojo;
import com.databasir.dao.tables.pojos.UserPojo;
import lombok.RequiredArgsConstructor;
import org.springframework.data.domain.Page;
@@ -22,58 +22,59 @@ import java.util.stream.Collectors;
@Service
@RequiredArgsConstructor
public class DocumentRemarkService {
public class DocumentDiscussionService {
private final DocumentRemarkDao documentRemarkDao;
private final DocumentDiscussionDao documentDiscussionDao;
private final ProjectDao projectDao;
private final UserDao userDao;
private final RemarkResponseConverter remarkResponseConverter;
private final DiscussionResponseConverter discussionResponseConverter;
public void deleteById(Integer groupId,
Integer projectId,
Integer remarkId) {
Integer discussionId) {
if (projectDao.exists(groupId, projectId)) {
documentRemarkDao.deleteById(remarkId);
documentDiscussionDao.deleteById(discussionId);
} else {
throw new Forbidden();
}
}
public Page<RemarkResponse> list(Integer groupId,
Integer projectId,
Pageable pageable,
RemarkListCondition condition) {
public Page<DiscussionResponse> list(Integer groupId,
Integer projectId,
Pageable pageable,
DiscussionListCondition condition) {
if (projectDao.exists(groupId, projectId)) {
Page<DocumentRemarkPojo> data = documentRemarkDao.selectByPage(pageable, condition.toCondition(projectId));
Page<DocumentDiscussionPojo> data =
documentDiscussionDao.selectByPage(pageable, condition.toCondition(projectId));
Set<Integer> userIdList = data.getContent()
.stream()
.map(DocumentRemarkPojo::getUserId)
.map(DocumentDiscussionPojo::getUserId)
.collect(Collectors.toSet());
Map<Integer, UserPojo> userMapById = userDao.selectUserIdIn(userIdList)
.stream()
.collect(Collectors.toMap(UserPojo::getId, Function.identity()));
return data
.map(remarkPojo -> {
UserPojo userPojo = userMapById.get(remarkPojo.getUserId());
return remarkResponseConverter.of(remarkPojo, userPojo);
.map(dicussionPojo -> {
UserPojo userPojo = userMapById.get(dicussionPojo.getUserId());
return discussionResponseConverter.of(dicussionPojo, userPojo);
});
} else {
throw new Forbidden();
}
}
public void create(Integer groupId, Integer projectId, Integer userId, RemarkCreateRequest request) {
public void create(Integer groupId, Integer projectId, Integer userId, DiscussionCreateRequest request) {
if (projectDao.exists(groupId, projectId)) {
DocumentRemarkPojo pojo = new DocumentRemarkPojo();
DocumentDiscussionPojo pojo = new DocumentDiscussionPojo();
pojo.setUserId(userId);
pojo.setProjectId(projectId);
pojo.setRemark(request.getRemark());
pojo.setContent(request.getContent());
pojo.setTableName(request.getTableName());
pojo.setColumnName(request.getColumnName());
documentRemarkDao.insertAndReturnId(pojo);
documentDiscussionDao.insertAndReturnId(pojo);
} else {
throw new Forbidden();
}