261016_01_ENH: 1차 마이그레이션 완료

This commit is contained in:
2026-10-16 12:21:37 +09:00
parent 7ca665397e
commit 26088f6fd0
188 changed files with 10522 additions and 573 deletions

View File

@@ -0,0 +1,29 @@
package com.kri.kart.server.persistence;
import com.kri.kart.server.common.enums.ProjectType;
import java.util.Objects;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Component;
@Component
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class SurveySessionProvider {
private final SqlSessionTemplate konSqlSessionTemplate;
private final SqlSessionTemplate konkiwiSqlSessionTemplate;
public SurveySessionProvider(
@Qualifier("konSqlSessionTemplate") SqlSessionTemplate konSqlSessionTemplate,
@Qualifier("konkiwiSqlSessionTemplate") SqlSessionTemplate konkiwiSqlSessionTemplate) {
this.konSqlSessionTemplate = konSqlSessionTemplate;
this.konkiwiSqlSessionTemplate = konkiwiSqlSessionTemplate;
}
public SqlSessionTemplate forProject(ProjectType type) {
return switch (Objects.requireNonNull(type, "Project type is required")) {
case KON -> konSqlSessionTemplate;
case KIWI -> konkiwiSqlSessionTemplate;
};
}
}

View File

@@ -1,42 +0,0 @@
package com.kri.kart.server.persistence.entity;
import com.kri.kart.server.common.enums.ExampleStatus;
import com.kri.kart.server.persistence.entity.id.ExampleEntityId;
import jakarta.persistence.Column;
import jakarta.persistence.EmbeddedId;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.Table;
import lombok.AccessLevel;
import lombok.Builder;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@Entity
@Table(name = "t_example")
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class ExampleEntity {
@EmbeddedId
private ExampleEntityId id;
@Column(name = "name", nullable = false, length = 100)
private String name;
@Enumerated(EnumType.STRING)
@Column(name = "status", nullable = false, length = 20)
private ExampleStatus status;
@Builder
public ExampleEntity(ExampleEntityId id, String name, ExampleStatus status) {
this.id = id;
this.name = name;
this.status = status == null ? ExampleStatus.ACTIVE : status;
}
public void changeName(String name) {
this.name = name;
}
}

View File

@@ -1,28 +0,0 @@
package com.kri.kart.server.persistence.entity.id;
import jakarta.persistence.Column;
import jakarta.persistence.Embeddable;
import java.io.Serial;
import java.io.Serializable;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
@Getter
@Embeddable
@EqualsAndHashCode
@AllArgsConstructor
@NoArgsConstructor(access = AccessLevel.PROTECTED)
public class ExampleEntityId implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@Column(name = "group_id", nullable = false)
private Long groupId;
@Column(name = "sequence", nullable = false)
private Integer sequence;
}

View File

@@ -1,9 +0,0 @@
package com.kri.kart.server.persistence.jdbc;
public record ExampleBulkItem(
Long groupId,
Integer sequence,
String name,
String status
) {
}

View File

@@ -1,47 +0,0 @@
package com.kri.kart.server.persistence.jdbc;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.List;
import lombok.RequiredArgsConstructor;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
public class ExampleBulkJdbcRepository {
private final JdbcTemplate jdbcTemplate;
public void insertAll(List<ExampleBulkItem> items, int batchSize) {
if (items == null || items.isEmpty()) return;
String sql = """
insert into t_example (group_id, sequence, name, status)
values (?, ?, ?, ?)
""";
int safeBatchSize = Math.max(batchSize, 1);
for (int from = 0; from < items.size(); from += safeBatchSize) {
int to = Math.min(from + safeBatchSize, items.size());
List<ExampleBulkItem> batch = items.subList(from, to);
jdbcTemplate.batchUpdate(sql, new BatchPreparedStatementSetter() {
@Override
public void setValues(PreparedStatement statement, int index) throws SQLException {
ExampleBulkItem item = batch.get(index);
statement.setLong(1, item.groupId());
statement.setInt(2, item.sequence());
statement.setString(3, item.name());
statement.setString(4, item.status());
}
@Override
public int getBatchSize() {
return batch.size();
}
});
}
}
}

View File

@@ -1,11 +0,0 @@
package com.kri.kart.server.persistence.mapper;
import com.kri.kart.server.dto.response.ExampleResponse;
import java.util.List;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
@Mapper
public interface ExampleMapper {
List<ExampleResponse> findByName(@Param("keyword") String keyword);
}

View File

@@ -1,15 +0,0 @@
package com.kri.kart.server.persistence.query;
import com.kri.kart.server.persistence.entity.QExampleEntity;
import com.querydsl.core.types.dsl.BooleanExpression;
public final class ExamplePredicates {
private ExamplePredicates() {
}
public static BooleanExpression nameContains(QExampleEntity example, String keyword) {
if (keyword == null || keyword.isBlank()) return null;
return example.name.containsIgnoreCase(keyword.trim());
}
}

View File

@@ -0,0 +1,70 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.bookmark.BookmarkDto;
import com.kri.kart.server.dto.bookmark.BookmarkSaveRequestDto;
import com.kri.kart.server.dto.project.ProjectRefDto;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class BookmarkRepository {
private final SqlSessionTemplate kartSqlSessionTemplate;
public BookmarkRepository(
@Qualifier("kartSqlSessionTemplate") SqlSessionTemplate kartSqlSessionTemplate) {
this.kartSqlSessionTemplate = kartSqlSessionTemplate;
}
public List<BookmarkDto> list(ProjectRefDto project, String page, String userId) {
Map<String, Object> params = new HashMap<>();
params.put("pkey", project.getPkey());
params.put("page", page);
params.put("userId", userId);
return kartSqlSessionTemplate.selectList("kart.Bookmark.list", params);
}
public BookmarkDto find(ProjectRefDto project, String bookmarkId) {
return kartSqlSessionTemplate.selectOne("kart.Bookmark.find", keys(project, bookmarkId));
}
public int create(
ProjectRefDto project,
String bookmarkId,
BookmarkSaveRequestDto request,
String userTeam,
String userId) {
Map<String, Object> params = keys(project, bookmarkId);
params.put("request", request);
params.put("userTeam", userTeam);
params.put("userId", userId);
return kartSqlSessionTemplate.insert("kart.Bookmark.create", params);
}
public int update(ProjectRefDto project, String bookmarkId, BookmarkSaveRequestDto request) {
Map<String, Object> params = keys(project, bookmarkId);
params.put("request", request);
return kartSqlSessionTemplate.update("kart.Bookmark.update", params);
}
public int shiftOrderAfterDelete(ProjectRefDto project, String bookmarkId) {
return kartSqlSessionTemplate.update(
"kart.Bookmark.shiftOrderAfterDelete", keys(project, bookmarkId));
}
public int delete(ProjectRefDto project, String bookmarkId) {
return kartSqlSessionTemplate.delete("kart.Bookmark.delete", keys(project, bookmarkId));
}
private Map<String, Object> keys(ProjectRefDto project, String bookmarkId) {
Map<String, Object> params = new HashMap<>();
params.put("pkey", project.getPkey());
params.put("bookmarkId", bookmarkId);
return params;
}
}

View File

@@ -0,0 +1,137 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.derived.DerivedDataDto;
import com.kri.kart.server.dto.derived.DerivedDefinitionDto;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.dto.question.QuestionDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class DerivedRepository {
private final SurveySessionProvider surveySessionProvider;
public List<QuestionDto> list(ProjectRefDto project, Integer userRole, String userTeam) {
Map<String, Object> params = new HashMap<>();
params.put("pkey", project.getPkey());
params.put("userRole", userRole);
params.put("userTeam", userTeam);
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Derived.list", params);
}
public String lockProject(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectOne("kart.Derived.lockProject", Map.of("pkey", project.getPkey()));
}
public List<DerivedDefinitionDto> definitions(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Derived.definitions", Map.of("pkey", project.getPkey()));
}
public DerivedDefinitionDto find(ProjectRefDto project, String qid) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectOne("kart.Derived.find", keys(project, qid));
}
public boolean duplicate(ProjectRefDto project, String qid, String originId) {
var params = keys(project, qid);
params.put("originId", originId == null ? "" : originId);
return surveySessionProvider
.forProject(project.getProjectType())
.<Integer>selectOne("kart.Derived.duplicate", params)
> 0;
}
public int save(
ProjectRefDto project,
DerivedDefinitionDto definition,
String originId,
String userTeam,
String userId) {
var params = keys(project, definition.getQid());
params.put("questionJson", definition.getQuestionJson());
params.put("derivedJson", definition.getDerivedJson());
params.put("originId", originId);
params.put("userTeam", userTeam);
params.put("userId", userId);
var session = surveySessionProvider.forProject(project.getProjectType());
return originId == null
? session.insert("kart.Derived.create", params)
: session.update("kart.Derived.update", params);
}
public void shiftOrder(ProjectRefDto project, String qid) {
surveySessionProvider
.forProject(project.getProjectType())
.update("kart.Derived.shiftOrder", keys(project, qid));
}
public int delete(ProjectRefDto project, String qid) {
return surveySessionProvider
.forProject(project.getProjectType())
.delete("kart.Derived.delete", keys(project, qid));
}
public void clearData(ProjectRefDto project, String qid) {
surveySessionProvider
.forProject(project.getProjectType())
.update("kart.Derived.clearData", keys(project, qid));
}
public List<DerivedDataDto> responses(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Derived.responses", Map.of("pkey", project.getPkey()));
}
public void ensureRespondent(ProjectRefDto project, String idkey) {
surveySessionProvider
.forProject(project.getProjectType())
.update("kart.Derived.ensureRespondent", Map.of("pkey", project.getPkey(), "idkey", idkey));
}
public void clearRespondentData(ProjectRefDto project, String qid, String idkey) {
var params = keys(project, qid);
params.put("idkey", idkey);
surveySessionProvider
.forProject(project.getProjectType())
.update("kart.Derived.clearRespondentData", params);
}
public List<DerivedDataDto> respondentResponses(ProjectRefDto project, String idkey) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList(
"kart.Derived.respondentResponses", Map.of("pkey", project.getPkey(), "idkey", idkey));
}
public void saveData(ProjectRefDto project, String qid, String idkey, String groupJson) {
var params = keys(project, qid);
params.put("idkey", idkey);
params.put("groupJson", groupJson);
surveySessionProvider
.forProject(project.getProjectType())
.update("kart.Derived.saveData", params);
}
private Map<String, Object> keys(ProjectRefDto project, String qid) {
var params = new HashMap<String, Object>();
params.put("pkey", project.getPkey());
params.put("qid", qid);
params.put("jsonPath", "$.\"" + qid + "\"");
return params;
}
}

View File

@@ -1,8 +0,0 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.persistence.entity.ExampleEntity;
import java.util.List;
public interface ExampleQueryRepository {
List<ExampleEntity> findByNameContains(String keyword, int limit);
}

View File

@@ -1,25 +0,0 @@
package com.kri.kart.server.persistence.repository;
import static com.kri.kart.server.persistence.entity.QExampleEntity.exampleEntity;
import com.kri.kart.server.persistence.entity.ExampleEntity;
import com.kri.kart.server.persistence.query.ExamplePredicates;
import com.querydsl.jpa.impl.JPAQueryFactory;
import java.util.List;
import lombok.RequiredArgsConstructor;
@RequiredArgsConstructor
public class ExampleQueryRepositoryImpl implements ExampleQueryRepository {
private final JPAQueryFactory jpaQueryFactory;
@Override
public List<ExampleEntity> findByNameContains(String keyword, int limit) {
return jpaQueryFactory
.selectFrom(exampleEntity)
.where(ExamplePredicates.nameContains(exampleEntity, keyword))
.orderBy(exampleEntity.id.groupId.asc(), exampleEntity.id.sequence.asc())
.limit(Math.max(limit, 1))
.fetch();
}
}

View File

@@ -1,9 +0,0 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.persistence.entity.ExampleEntity;
import com.kri.kart.server.persistence.entity.id.ExampleEntityId;
import org.springframework.data.jpa.repository.JpaRepository;
public interface ExampleRepository
extends JpaRepository<ExampleEntity, ExampleEntityId>, ExampleQueryRepository {
}

View File

@@ -0,0 +1,62 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.export.ExportDataDto;
import com.kri.kart.server.dto.export.ExportDerivedHeaderDto;
import com.kri.kart.server.dto.export.ExportHeaderDto;
import com.kri.kart.server.dto.export.ExportTitleDto;
import com.kri.kart.server.dto.export.RawDataExportRequestDto;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class ExportRepository {
private final SurveySessionProvider surveySessionProvider;
public String additionalColumns(ProjectRefDto project) {
return session(project)
.selectOne("kart.Export.additionalColumns", Map.of("pkey", project.getPkey()));
}
public List<ExportDerivedHeaderDto> derivedHeaders(ProjectRefDto project) {
return session(project)
.selectList("kart.Export.derivedHeaders", Map.of("pkey", project.getPkey()));
}
public List<ExportHeaderDto> questionHeaders(ProjectRefDto project) {
return session(project)
.selectList("kart.Export.questionHeaders", Map.of("pkey", project.getPkey()));
}
public List<ExportTitleDto> titles(ProjectRefDto project) {
return session(project).selectList("kart.Export.titles", Map.of("pkey", project.getPkey()));
}
public String surveyType(ProjectRefDto project) {
return session(project).selectOne("kart.Export.surveyType", Map.of("pkey", project.getPkey()));
}
public List<ExportDataDto> data(
ProjectRefDto project, RawDataExportRequestDto request, boolean includeInterviewer) {
Map<String, Object> parameters = new HashMap<>();
parameters.put("pkey", project.getPkey());
parameters.put("type", request.getType());
parameters.put("startDate", request.getStartDate());
parameters.put(
"endDate", request.getEndDate() == null ? request.getStartDate() : request.getEndDate());
parameters.put("includeInterviewer", includeInterviewer);
return session(project).selectList("kart.Export.data", parameters);
}
private SqlSessionTemplate session(ProjectRefDto project) {
return surveySessionProvider.forProject(project.getProjectType());
}
}

View File

@@ -0,0 +1,59 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.dto.upload.ImportQuestionDto;
import com.kri.kart.server.dto.upload.ImportResponseDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class ImportRepository {
private final SurveySessionProvider surveySessionProvider;
public String lockProject(ProjectRefDto project) {
return session(project).selectOne("kart.Import.lockProject", Map.of("pkey", project.getPkey()));
}
public int command(ProjectRefDto project, String statement) {
return session(project).update("kart.Import." + statement, Map.of("pkey", project.getPkey()));
}
public int title(ProjectRefDto project, String qid, String explain) {
return session(project)
.update(
"kart.Import.title", Map.of("pkey", project.getPkey(), "qid", qid, "explain", explain));
}
public int question(ProjectRefDto project, ImportQuestionDto question) {
return session(project)
.insert("kart.Import.question", Map.of("pkey", project.getPkey(), "question", question));
}
public int structure(ProjectRefDto project, ImportQuestionDto question) {
return session(project)
.update(
"kart.Import.structure",
Map.of(
"pkey",
project.getPkey(),
"question",
question,
"jsonPath",
"$." + question.getQid()));
}
public int response(ProjectRefDto project, ImportResponseDto response) {
return session(project)
.insert("kart.Import.response", Map.of("pkey", project.getPkey(), "response", response));
}
private SqlSessionTemplate session(ProjectRefDto project) {
return surveySessionProvider.forProject(project.getProjectType());
}
}

View File

@@ -0,0 +1,52 @@
package com.kri.kart.server.persistence.repository;
import java.util.Map;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Repository
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class LogRepository {
private final SqlSessionTemplate kartSqlSessionTemplate;
public LogRepository(
@Qualifier("kartSqlSessionTemplate") SqlSessionTemplate kartSqlSessionTemplate) {
this.kartSqlSessionTemplate = kartSqlSessionTemplate;
}
@Transactional(transactionManager = "kartTransactionManager")
public void writeLoginLog(String userId, String clientIp) {
kartSqlSessionTemplate.insert(
"kart.Log.loginLog",
Map.of("userId", userId, "clientIp", clientIp == null ? "" : clientIp));
}
@Transactional(transactionManager = "kartTransactionManager")
public void writeVisitLog(String userId, String pkey, String pageInfo, String clientIp) {
kartSqlSessionTemplate.insert(
"kart.Log.visitLog",
Map.of(
"userId",
userId,
"pkey",
pkey,
"pageInfo",
pageInfo,
"clientIp",
clientIp == null ? "" : clientIp));
}
@Transactional(
transactionManager = "kartTransactionManager",
propagation = Propagation.REQUIRES_NEW)
public void writeSiteLog(String userId, String pageInfo, String clientIp) {
kartSqlSessionTemplate.insert(
"kart.Log.siteLog",
Map.of(
"userId", userId, "pageInfo", pageInfo, "clientIp", clientIp == null ? "" : clientIp));
}
}

View File

@@ -0,0 +1,28 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.statistics.NlpDictionaryWordDto;
import java.util.List;
import java.util.Map;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class NlpRepository {
private final SqlSessionTemplate kartSqlSessionTemplate;
public NlpRepository(
@Qualifier("kartSqlSessionTemplate") SqlSessionTemplate kartSqlSessionTemplate) {
this.kartSqlSessionTemplate = kartSqlSessionTemplate;
}
public List<String> tags(String pkey, String qid) {
return kartSqlSessionTemplate.selectList("kart.Nlp.tags", Map.of("pkey", pkey, "qid", qid));
}
public List<NlpDictionaryWordDto> words(String pkey, String qid) {
return kartSqlSessionTemplate.selectList("kart.Nlp.words", Map.of("pkey", pkey, "qid", qid));
}
}

View File

@@ -0,0 +1,67 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.project.CustomProgressDto;
import com.kri.kart.server.dto.project.LoiDto;
import com.kri.kart.server.dto.project.ProgressDayDto;
import com.kri.kart.server.dto.project.ProgressScreenDto;
import com.kri.kart.server.dto.project.ProgressSearchDto;
import com.kri.kart.server.dto.project.ProgressTypeDto;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class ProgressRepository {
private final SurveySessionProvider surveySessionProvider;
public List<ProgressDayDto> daily(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Progress.daily", Map.of("pkey", project.getPkey()));
}
public List<ProgressTypeDto> type(ProjectRefDto project, ProgressSearchDto search) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Progress.type", params(project, search));
}
public List<LoiDto> loi(ProjectRefDto project, ProgressSearchDto search) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Progress.loi", params(project, search));
}
public List<ProgressScreenDto> screen(ProjectRefDto project, ProgressSearchDto search) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Progress.screen", params(project, search));
}
public List<CustomProgressDto> reportUrls(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Progress.reportUrls", Map.of("pkey", project.getPkey()));
}
public List<CustomProgressDto> appendFiles(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Progress.appendFiles", Map.of("pkey", project.getPkey()));
}
private Map<String, Object> params(ProjectRefDto project, ProgressSearchDto search) {
Map<String, Object> result = new HashMap<>();
result.put("pkey", project.getPkey());
result.put("startDate", search.getStartDate());
result.put("endDate", search.getEndDate());
return result;
}
}

View File

@@ -0,0 +1,86 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.common.enums.ProjectType;
import com.kri.kart.server.dto.project.ProjectListDto;
import com.kri.kart.server.dto.project.ProjectSummaryDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class ProjectRepository {
private final SurveySessionProvider surveySessionProvider;
private final SqlSessionTemplate kartSqlSessionTemplate;
public ProjectRepository(
SurveySessionProvider surveySessionProvider,
@Qualifier("kartSqlSessionTemplate") SqlSessionTemplate kartSqlSessionTemplate) {
this.surveySessionProvider = surveySessionProvider;
this.kartSqlSessionTemplate = kartSqlSessionTemplate;
}
public List<String> findMustViewPkeys(ProjectType type) {
return kartSqlSessionTemplate.selectList(
"kart.Project.mustViewPkeys", Map.of("projectType", type.getCode()));
}
public List<String> findAssignedPkeys(String userId) {
return kartSqlSessionTemplate.selectList(
"kart.Project.assignedPkeys", Map.of("userId", userId));
}
public List<ProjectListDto> list(
ProjectType type,
List<String> excluded,
List<String> mustView,
Integer userRole,
String userTeam,
List<String> assignedPkeys) {
var params = visibility(userRole, userTeam, assignedPkeys);
params.put("projectType", type.getCode());
params.put("excludedOwnerIds", excluded);
params.put("mustViewPkeys", mustView);
return surveySessionProvider.forProject(type).selectList("kart.Project.list", params);
}
public List<ProjectListDto> linkedList(
ProjectType type,
String intranetCode,
String userTeam,
String keyword,
Integer userRole,
String authenticatedUserTeam,
List<String> assignedPkeys) {
var params = visibility(userRole, authenticatedUserTeam, assignedPkeys);
params.put("intranetCode", intranetCode);
params.put("userTeam", userTeam);
params.put("keyword", keyword);
return surveySessionProvider.forProject(type).selectList("kart.Project.linkedList", params);
}
public List<ProjectSummaryDto> summary(
ProjectType type,
List<String> excluded,
Integer userRole,
String userTeam,
List<String> assignedPkeys) {
var params = visibility(userRole, userTeam, assignedPkeys);
params.put("excludedOwnerIds", excluded);
return surveySessionProvider.forProject(type).selectList("kart.Project.summary", params);
}
private Map<String, Object> visibility(
Integer userRole, String userTeam, List<String> assignedPkeys) {
Map<String, Object> params = new HashMap<>();
params.put("userRole", userRole);
params.put("authenticatedUserTeam", userTeam);
params.put("assignedPkeys", assignedPkeys);
return params;
}
}

View File

@@ -0,0 +1,25 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.dto.question.QuestionDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class QuestionRepository {
private final SurveySessionProvider surveySessionProvider;
public List<QuestionDto> list(ProjectRefDto project, boolean includeProfiles) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList(
"kart.Question.list",
Map.of("pkey", project.getPkey(), "includeProfiles", includeProfiles));
}
}

View File

@@ -0,0 +1,38 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.dto.quota.QuotaEntryDto;
import com.kri.kart.server.dto.quota.QuotaSetDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class QuotaRepository {
private final SurveySessionProvider surveySessionProvider;
public List<QuotaSetDto> quotaSets(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Quota.quotaSets", Map.of("pkey", project.getPkey()));
}
public QuotaSetDto quotaSet(ProjectRefDto project, int quotaOrder) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectOne(
"kart.Quota.quotaSet", Map.of("pkey", project.getPkey(), "quotaOrder", quotaOrder));
}
public List<QuotaEntryDto> quotaEntries(ProjectRefDto project, int quotaOrder) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectList(
"kart.Quota.quotaEntries", Map.of("pkey", project.getPkey(), "quotaOrder", quotaOrder));
}
}

View File

@@ -0,0 +1,51 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.dto.share.ShareLinkRecordDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.Map;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class ShareLinkRepository {
private final SqlSessionTemplate kartSqlSessionTemplate;
private final SurveySessionProvider surveySessionProvider;
public ShareLinkRepository(
@Qualifier("kartSqlSessionTemplate") SqlSessionTemplate kartSqlSessionTemplate,
SurveySessionProvider surveySessionProvider) {
this.kartSqlSessionTemplate = kartSqlSessionTemplate;
this.surveySessionProvider = surveySessionProvider;
}
public ShareLinkRecordDto find(String urlKey) {
return kartSqlSessionTemplate.selectOne("kart.ShareLink.find", urlKey);
}
public String projectTitle(ProjectRefDto project) {
return surveySessionProvider
.forProject(project.getProjectType())
.selectOne("kart.ShareLink.projectTitle", project.getPkey());
}
public ShareLinkRecordDto reusable(ShareLinkRecordDto link) {
return kartSqlSessionTemplate.selectOne("kart.ShareLink.reusable", link);
}
public boolean keyExists(String urlKey) {
return kartSqlSessionTemplate.<Integer>selectOne("kart.ShareLink.keyExists", urlKey) > 0;
}
public int create(ShareLinkRecordDto link) {
return kartSqlSessionTemplate.insert("kart.ShareLink.create", link);
}
public int incrementLanding(ShareLinkRecordDto link) {
return kartSqlSessionTemplate.update(
"kart.ShareLink.incrementLanding", Map.of("id", link.getId(), "urlKey", link.getUrlKey()));
}
}

View File

@@ -0,0 +1,38 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.project.ProjectRefDto;
import com.kri.kart.server.dto.statistics.StatisticsDataDto;
import com.kri.kart.server.dto.statistics.StatisticsRequestDto;
import com.kri.kart.server.persistence.SurveySessionProvider;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.RequiredArgsConstructor;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@RequiredArgsConstructor
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class StatisticsRepository {
private final SurveySessionProvider surveySessionProvider;
public List<StatisticsDataDto> data(
ProjectRefDto project,
StatisticsRequestDto request,
boolean includeProfiles,
List<String> selectedRoots) {
Map<String, Object> params = new HashMap<>();
params.put("pkey", project.getPkey());
params.put("dataScope", request.getDataScope());
params.put("startDate", request.getStartDate());
params.put(
"endDate", request.getEndDate() == null ? request.getStartDate() : request.getEndDate());
params.put("includeProfiles", includeProfiles);
params.put("selectedRoots", selectedRoots);
params.put("hasFilter", request.getFilter() != null);
return surveySessionProvider
.forProject(project.getProjectType())
.selectList("kart.Statistics.data", params);
}
}

View File

@@ -0,0 +1,26 @@
package com.kri.kart.server.persistence.repository;
import com.kri.kart.server.dto.auth.LoginRequestDto;
import com.kri.kart.server.dto.auth.ReportMemberDto;
import java.util.List;
import org.mybatis.spring.SqlSessionTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.stereotype.Repository;
@Repository
@ConditionalOnProperty(prefix = "kri.kart.database", name = "enabled", havingValue = "true")
public class UserRepository {
private final SqlSessionTemplate kartSqlSessionTemplate;
public UserRepository(
@Qualifier("kartSqlSessionTemplate") SqlSessionTemplate kartSqlSessionTemplate) {
this.kartSqlSessionTemplate = kartSqlSessionTemplate;
}
public ReportMemberDto findMember(LoginRequestDto request) {
List<ReportMemberDto> users =
kartSqlSessionTemplate.selectList("kart.User.findMember", request);
return users.isEmpty() ? null : users.get(0);
}
}