Page History

import java.io.*;
import java.nio.charset.Charset;
import java.util.Comparator;
import java.util.List;

@Slf4j
@Service
//public 결과를class 새로운DocumentVersionService 형식으로{
변환 (id, createdAt, name)
            List<Map<String, Object>> formattedData = results.stream().map(version -> {
                Map<String, Object> versionData = new HashMap<>();
                versionData.put("id", version.getId());
                versionData.put("date", version.getCreatedAt());
                versionData.put("author", version.getName());
                return versionData;
            }).collect(Collectors.toList());

            ObjectMapper objectMapper = new ObjectMapper();
            String jsonResponse = objectMapper.writeValueAsString(formattedData);

            return ResponseEntity.ok(jsonResponse);

        } catch (Exception e) {
            return ResponseEntity.status(500).body("{\"message\": \"Internal server error\", \"error\": \"" + e.getMessage() + "\"}");
        }
    }

    /**
     * 문서 버전 데이터 가져오기
     */
    @PostMapping("/getDocumentVersionData")
    public String getDocumentVersionData(@RequestBody Map<String, Object> request) throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        String id = (String) request.get("id");
        DocumentVersion documentVersion = documentVersionRepository.findVersionsById(id);
        return objectMapper.writeValueAsString(documentVersion.getJson());
    }

    /**
     * 문서 버전 데이터 삭제
     */
    @DeleteMapping("/getDocumentVersionData")
    public ResponseEntity<Map<String, Object>> deleteDocumentVersionData(@RequestBody Map<String, Object> request) {
        String id = (String) request.get("id");

        try {
            DocumentVersion documentVersion = documentVersionRepository.findVersionsById(id);

            if (documentVersion != null) {
                documentVersionRepository.delete(documentVersion);
                return ResponseEntity.ok(Map.of("message", "Document deleted successfully."));
            } else {
                return ResponseEntity.status(404).body(Map.of("message", "Document not found."));
            }
        } catch (Exception e) {
            return ResponseEntity.status(500).body(Map.of("message", "Internal server error", "error", e.getMessage()));
        }
    }
}	@Autowired
	DocumentVersionModelDao documentVersionModelDao;
	@Autowired
	SynapUserInfoDao synapUserInfoDao;
	
	public void insertDocumentVersion(String userId, int domainId, long docId, String json) {
		documentVersionModelDao.insert(new DocumentVersionModel(userId, domainId, docId, json));
	}

	public String getDocumentVersionJson(long id) {
		return documentVersionModelDao.getDocumentVersionById(id).getJson();
	}

	public List<DocumentVersionModel> getDocumentVersions(long docId) {
		List<DocumentVersionModel> documentVersionModelList = documentVersionModelDao.getDocumentVersionByDocId(docId);
		documentVersionModelList.sort(Comparator.comparing(DocumentVersionModel::getUserId));

		String currentUserId = "";
		String targetUsername = "";

		for (DocumentVersionModel model : documentVersionModelList) {
			if (!model.getUserId().equals(currentUserId)) {
				currentUserId = model.getUserId();
				targetUsername = synapUserInfoDao.getUserInfoByUserIdAndDomain(currentUserId, model.getDomainId()).getUserName();
			}
			model.setUsername(targetUsername);
		}
		documentVersionModelList.sort(Comparator.comparing(DocumentVersionModel::getId).reversed());
		return documentVersionModelList;
	}

	public void deleteDocumentVersion(long id) {
		documentVersionModelDao.delete(id);
	}
}

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Repository;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Slf4j
@Repository
public class DocumentVersionModelDao extends AbstractDao {
    public void insert(DocumentVersionModel documentVersionModel) {
        insert("DocumentVersion.insert", documentVersionModel);
    }

    public void delete(long id) { delete("DocumentVersion.remove", id); }

    public DocumentVersionModel getDocumentVersionById(long id) {
        Map<String, Object> params = new HashMap<>();
        params.put("id", id);
        return (DocumentVersionModel) select("DocumentVersion.getDocumentVersionById", params);
    }

    public List<DocumentVersionModel> getDocumentVersionByDocId(long docId) {
        return list("DocumentVersion.getDocumentVersionByDocId", docId);
    }
}

import com.ibatis.sqlmap.client.SqlMapClient;
import org.springframework.orm.ibatis.support.SqlMapClientDaoSupport;

import javax.annotation.Resource;
import java.util.List;

@SuppressWarnings("deprecation")
public abstract class AbstractDao extends SqlMapClientDaoSupport {
    protected AbstractDao() {

	}

    public final Object insert(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().insert(queryId, parameterObject);
	}

    public final int update(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().update(queryId, parameterObject);
	}

    public final int delete(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().delete(queryId, parameterObject);
	}

    public final Object select(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().queryForObject(queryId, parameterObject);
	}

    @SuppressWarnings("rawtypes")
	public final List list(final String queryId, final Object parameterObject) {
		return getSqlMapClientTemplate().queryForList(queryId, parameterObject);
	}

}

import lombok.Data;
import lombok.NoArgsConstructor;

import java.io.Serializable;
import java.sql.Date;

@Data
@NoArgsConstructor
public class DocumentVersionModel implements Serializable {
    private long id;
	private String userId;
	private int domainId;
	private String username;
	private long docId;
	private String json;
	private Date createdAt;

	DocumentVersionModel(String userId, int domainId, long docId, String json) {
		this.userId = userId;
		this.domainId = domainId;
		this.docId = docId;
		this.json = json;
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE sqlMap PUBLIC "-//ibatis.apache.org//DTD SQL Map 2.0//EN" "http://ibatis.apache.org/dtd/sql-map-2.dtd">

<sqlMap namespace="DocumentVersion">
	<resultMap id="documentVersion" class="(DocumentVersionModel path)">
		<result property="id" column="id" columnIndex="1"/>
		<result property="userId" column="user_id" columnIndex="2"/>
		<result property="domainId" column="domain_id" columnIndex="3"/>
		<result property="docId" column="doc_id" columnIndex="4"/>
		<result property="json" column="json" columnIndex="5"/>
		<result property="createdAt" column="created_at" columnIndex="6"/>
	</resultMap>
	<resultMap id="documentVersionList" class="(DocumentVersionModel path)">
		<result property="id" column="id" columnIndex="1"/>
		<result property="userId" column="user_id" columnIndex="2"/>
		<result property="domainId" column="domain_id" columnIndex="3"/>
		<result property="docId" column="doc_id" columnIndex="4"/>
		<result property="createdAt" column="created_at" columnIndex="5"/>
	</resultMap>

	<insert id="insert">
		INSERT INTO
			document_version(user_id, domain_id, doc_id, json, created_at)
		VALUES
			(#userId#, #domainId#, #docId# , #json#, SYSDATE())
	</insert>
	
    <delete id="remove">
		DELETE FROM document_version
		WHERE id = #id#
	</delete>

	<select id="getDocumentVersionById" resultMap="documentVersion">
		SELECT id, user_id, domain_id, doc_id, json, created_at
		FROM document_version
		WHERE
			id = #id#
	</select>

	<select id="getDocumentVersionByDocId" resultClass="java.util.List" resultMap="documentVersionList">
		SELECT id, user_id, domain_id, doc_id, created_at
		FROM document_version
		WHERE
			doc_id = #docId#
		ORDER BY id DESC
		LIMIT 500
	</select>
</sqlMap>