1package jp.co.smsdatatech.questiongenerate.entity;

 2 

 3import java.io.Serializable;

 4import lombok.Data;

 5 

 6/**

 7 * TrialExamHistoryテーブルEntity

 8 */

 9@Data

10public class TrialExamHistoryEntity implements Serializable {

11 

12    /** シリアルバージョンUID */

13    private static final long serialVersionUID = 1L;

14 

15    /** 試験履歴ID */

16    private Integer trialExamHistoryId;

17 

18    /** 試験ID */

19    private Integer trialExamId;

20 

21    /** 試験回数 */

22    private Integer trialExamTimes;

23 

24    /** 試験スコア */

25    private Integer trialScore;

26 

27    /** ユーザーID */

28    private Integer userId;

29}

 1<mapper namespace="jp.co.smsdatatech.questiongenerate.repository.TrialExamHistoryMapper">

 2 

 3    <select id="selectLatestTrialExamHistoryList" resultMap="TrialExamHistoryResultMap" resultType="jp.co.smsdatatech.questiongenerate.entity.TrialExamHistoryEntity">

 4        SELECT

 5            highest_score_exam.user_id,

 6            highest_score_exam.trial_exam_id,

 7            highest_score_exam.trial_exam_score,

 8            highest_score_exam.trial_exam_times

 9        FROM

10            (

11                SELECT

12                    teh.user_id,

13                    teh.trial_exam_id,

14                    teh.trial_exam_score,

15                    teh.trial_exam_times,

16                    RANK() OVER (PARTITION BY teh.user_id ORDER BY teh.trial_exam_score DESC, teh.trial_exam_times DESC) AS rank_num

17                FROM

18                    trial_exam_history teh

19                JOIN

20                    trial_exam AS exam

21                    ON teh.trial_exam_id = exam.trial_exam_id

22                WHERE

23                    exam.course_id = #{courseId}

24            ) AS highest_score_exam

25        WHERE

26            highest_score_exam.rank_num = 1;

27    </select>

28</mapper>

 1/**

 2 * 指定したコースIDに基づいて、複数ユーザーの最新試験履歴を取得する。

 3 *

 4 * @param courseId コースID

 5 * @return 最新の模擬試験履歴リスト

 6 */

 7@Transactional(readOnly = true)

 8public List<TrialExamHistoryEntity> selectLatestTrialExamHistoryList(Integer courseId) {

 9 

10    log.debug("コースID {} の最新の模擬試験履歴を取得します。", courseId);

11 

12    // データベースから複数ユーザーの最新試験履歴を取得

13    List<TrialExamHistoryEntity> latestTrialExamHistoryList = trialExamHistoryMapper

14            .selectLatestTrialExamHistoryList(courseId);

15 

16    log.debug("取得した複数ユーザーの最新模擬試験履歴リスト: {}", latestTrialExamHistoryList);

17 

18    return latestTrialExamHistoryList;

19}

 1/**

 2 * 最新の模擬試験履歴を取得（スコア範囲ごとの人数分布のみ返却）。

 3 *

 4 * <h3>機能概要</h3>

 5 * コースIDに基づいて、スコア範囲ごとの人数分布を取得する。

 6 *

 7 * <h3>処理フロー</h3>

 8 * 1. リクエストデータのバリデーション<br>

 9 * 2. サービスクラスを呼び出して、スコア範囲ごとの人数分布を取得<br>

10 * 3. スコア範囲ごとの人数分布が見つからない場合はエラーメッセージを設定<br>

11 * 4. スコア範囲ごとの人数分布を返却

12 *

13 * @param form    UserIdForm

14 * @param result  バリデーション結果やエラーを格納

15 * @return スコア範囲ごとの人数分布 ScoreDistributionResponseForm

16 */

17@PostMapping("/top/getScoreDistribution")

18public ScoreDistributionResponseForm getScoreDistribution(

19        @RequestBody @Validated({ ValidationGroups.Step1.class, ValidationGroups.Step2.class }) UserIdForm form,

20        BindingResult result) {

21    log.debug("TopRest (getScoreDistribution) 呼び出し開始");

22 

23    ScoreDistributionResponseForm responseForm = new ScoreDistributionResponseForm();

24    List<String> errorMessageList = new ArrayList<>();

25 

26    // バリデーションエラーがある場合、詳細なエラーメッセージを追加

27    if (result.hasErrors()) {

28        for (FieldError fieldError : result.getFieldErrors()) {

29            String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault());

30            errorMessageList.add(errorMessage);

31        }

32        responseForm.setErrorMessageList(errorMessageList);

33        return responseForm;

34    }

35 

36    Integer courseId = form.getCourseId();

37 

38    // 最新の模擬試験履歴リストを取得

39    List<TrialExamHistoryEntity> latestTrialExamHistoryList = trialExamHistoryService

40            .selectLatestTrialExamHistoryList(courseId);

41 

42    // リストが取得できなかった場合

43    if (CollectionUtils.isEmpty(latestTrialExamHistoryList)) {

44        errorMessageList

45                .add(messageSource.getMessage(ErrorMessages.TRIAL_EXAM_HISTORY_NOT_FOUND, null,

46                        Locale.getDefault()));

47        responseForm.setErrorMessageList(errorMessageList);

48        log.debug("最新の模擬試験履歴が見つかりませんでした");

49        return responseForm;

50    }

51 

52    // スコア範囲ごとの人数をカウントする

53    Map<String, Integer> scoreDistribution = new HashMap<>();

54    for (TrialExamHistoryEntity history : latestTrialExamHistoryList) {

55        int score = history.getTrialScore();

56        ScoreEnum range = ScoreEnum.getRange(score);

57        if (range != null) {

58            // スコア範囲に該当する人数を取り出し、1を加算する

59            int currentCount = scoreDistribution.getOrDefault(range.name(), 0);

60            scoreDistribution.put(range.name(), currentCount + 1);

61        }

62    }

63 

64    // スコア分布をResponseFormにセット

65    responseForm.setScoreDistribution(scoreDistribution);

66 

67    log.debug("TopRest (getScoreDistribution) 呼び出し終了");

68 

69    return responseForm;

70}

 1package jp.co.smsdatatech.questiongenerate.enums;

 2 

 3import lombok.Getter;

 4 

 5/**

 6 * スコア範囲を表す列挙型クラス。

 7 *

 8 * <p>

 9 * 各範囲はスコアの最小値と最大値によって定義されます。

10 * スコアを基に適切なスコア範囲を判定する機能を提供します。

11 * </p>

12 */

13@Getter

14public enum ScoreEnum {

15    A(90, 100),  // A範囲：90〜100

16    B(80, 89),   // B範囲：80〜89

17    C(70, 79),   // C範囲：70〜79

18    D(0, 69);    // D範囲：0〜69

19 

20    private final int minScore;

21    private final int maxScore;

22 

23    // コンストラクタ

24    ScoreEnum(int minScore, int maxScore) {

25        this.minScore = minScore;

26        this.maxScore = maxScore;

27    }

28 

29    // スコアがこの範囲に含まれるかどうかをチェック

30    public boolean isInRange(int score) {

31        return score >= minScore && score <= maxScore;

32    }

33}

 1package jp.co.smsdatatech.questiongenerate.entity;

 2 

 3import java.io.Serializable;

 4import lombok.Data;

 5 

 6/**

 7 * TrialExamHistoryテーブルEntity

 8 */

 9@Data

10public class TrialExamHistoryEntity implements Serializable {

11 

12    /** シリアルバージョンUID */

13    private static final long serialVersionUID = 1L;

14 

15    /** 試験履歴ID */

16    private Integer trialExamHistoryId;

17 

18    /** 試験ID */

19    private Integer trialExamId;

20 

21    /** 試験回数 */

22    private Integer trialExamTimes;

23 

24    /** 試験スコア */

25    private Integer trialScore;

26 

27    /** ユーザーID */

28    private Integer userId;

29}

 1package jp.co.smsdatatech.questiongenerate.repository;

 2 

 3import java.util.List;

 4import org.apache.ibatis.annotations.Mapper;

 5import org.apache.ibatis.annotations.Param;

 6 

 7import jp.co.smsdatatech.questiongenerate.entity.TrialExamHistoryEntity;

 8 

 9/**

10 * TrialExamHistoryテーブルMapper

11 */

12@Mapper

13public interface TrialExamHistoryMapper {

14 

15    /**

16     * 指定されたユーザーID、コースIDに基づいて直近5回分の模擬試験履歴を取得する。

17     *

18     * @param userId   ユーザーID

19     * @param courseId コースID

20     * @return 模擬試験スコアリスト

21     */

22    List<TrialExamHistoryEntity> selectTrialExamHistoryList(

23            @Param("userId") Integer userId,

24            @Param("courseId") Integer courseId);

25 

26    /**

27     * 指定したコースIDに基づいて、複数ユーザーの最新試験履歴を取得します。

28     *

29     * @param courseId コースID

30     * @return 最新の試験履歴リスト（各ユーザー1件）

31     */

32    List<TrialExamHistoryEntity> selectLatestTrialExamHistoryList(

33            @Param("courseId") Integer courseId);

34}

 1/**

 2 * 模擬試験履歴リスト作成Service

 3 */

 4@Slf4j

 5@Service

 6public class TrialExamHistoryService {

 7 

 8    private final TrialExamHistoryMapper trialExamHistoryMapper;

 9 

10    // コンストラクタインジェクションを使用

11    @Autowired

12    public TrialExamHistoryService(TrialExamHistoryMapper trialExamHistoryMapper) {

13        this.trialExamHistoryMapper = trialExamHistoryMapper;

14    }

15 

16    /**

17     * 指定されたユーザーID、コースIDに基づいて直近5回分の模擬試験履歴を取得する。

18     *

19     * @param userId   ユーザーID

20     * @param courseId コースID

21     * @return 模擬試験履歴リスト

22     */

23    @Transactional(readOnly = true)

24    public List<TrialExamHistoryEntity> selectTrialExamHistoryList(Integer userId, Integer courseId) {

25 

26        log.debug("ユーザーID {} のコースID {} の模擬試験履歴を取得します。", userId, courseId);

27 

28        // データベースから模擬試験履歴を取得

29        List<TrialExamHistoryEntity> trialExamHistoryList = trialExamHistoryMapper.selectTrialExamHistoryList(userId, courseId);

30        log.debug("取得した模擬試験履歴リスト: {}", trialExamHistoryList);

31 

32        return trialExamHistoryList;

33    }

34}

 1/**

 2 * 模擬試験履歴を取得.

 3 *

 4 * <h3>機能概要</h3>

 5 * ユーザーIDおよびコースIDに基づいて、模擬試験履歴を取得する。

 6 *

 7 * <h3>処理フロー</h3>

 8 * 1. リクエストデータのバリデーション<br>

 9 * 2. サービスクラスを呼び出して、模擬試験履歴を取得<br>

10 * 3. 履歴が見つからない場合はエラーメッセージを設定<br>

11 * 4. 模擬試験履歴またはエラーメッセージリストを返却

12 *

13 * @param form    ユーザーIDとコースIDのリクエストフォーム

14 * @param result  バリデーション結果やエラーを格納

15 * @return 模擬試験履歴リスト TrialExamHistoryResponseForm

16 */

17@PostMapping("/top/getTrialExamHistory")

18public TrialExamHistoryResponseForm getTrialExamHistory(

19        @RequestBody @Validated({ ValidationGroups.Step1.class, ValidationGroups.Step2.class }) UserIdForm form,

20        BindingResult result) {

21    log.debug("TrialExamHistoryRest (getTrialExamHistory) 呼び出し開始");

22 

23    TrialExamHistoryResponseForm responseForm = new TrialExamHistoryResponseForm();

24    List<String> errorMessageList = new ArrayList<>();

25 

26    // バリデーションエラーがある場合、詳細なエラーメッセージを追加

27    if (result.hasErrors()) {

28        for (FieldError fieldError : result.getFieldErrors()) {

29            String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault()); // Localeを指定

30            errorMessageList.add(errorMessage);

31        }

32        responseForm.setErrorMessageList(errorMessageList);

33        return responseForm;

34    }

35 

36    Integer userId = Integer.parseInt(form.getUserId());

37    Integer courseId = form.getCourseId();

38 

39    // 模擬試験履歴リストを取得

40    List<TrialExamHistoryEntity> trialExamHistoryList = trialExamHistoryService.selectTrialExamHistoryList(userId,

41            courseId);

42 

43    // リストが取得できなかった場合

44    if (CollectionUtils.isEmpty(trialExamHistoryList)) {

45        errorMessageList

46                .add(messageSource.getMessage(ErrorMessages.TRIAL_EXAM_HISTORY_NOT_FOUND, null,

47                        Locale.getDefault()));

48        responseForm.setErrorMessageList(errorMessageList);

49        log.debug("模擬試験履歴が見つかりませんでした");

50        return responseForm;

51    }

52 

53    responseForm.setTrialExamHistoryList(trialExamHistoryList);

54    log.debug("TrialExamHistoryRest (getTrialExamHistory) 呼び出し終了");

55 

56    return responseForm;

57}

 1package jp.co.smsdatatech.questiongenerate.entity;

 2 

 3import java.io.Serializable;

 4import java.math.BigDecimal;

 5 

 6import lombok.Data;

 7 

 8/**

 9 *

10 * ViewHistoryテーブルEntity

11 */

12@Data

13public class ViewHistoryEntity implements Serializable {

14 

15    /** シリアルバージョンUID */

16    private static final long serialVersionUID = 1L;

17 

18    /** 分野ID */

19    private Integer fieldId;

20 

21    /** 分野名 */

22    private String fieldName;

23 

24    /** 最大進捗率（集計結果） */

25    private BigDecimal fieldMaxProgress;

26}

 1<?xml version="1.0" encoding="UTF-8"?>

 2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 3<mapper namespace="jp.co.smsdatatech.questiongenerate.repository.ViewHistoryMapper">

 4 

 5    <select id="getViewHistoryWithMaxProgress" resultMap="ViewHistoryResultMap">

 6        SELECT

 7            subquery.course_id,

 8            subquery.field_id,

 9            subquery.fieldMaxProgress,

10            f.field_name

11        FROM

12            (SELECT

13                vh.course_id,

14                vh.field_id,

15                MAX(vh.progress_percentage) AS fieldMaxProgress

16            FROM

17                view_history vh

18            WHERE

19                vh.user_id = #{userId}

20                AND vh.course_id = #{courseId}

21                AND vh.viewed_at BETWEEN #{startOfWeek} AND #{endOfWeek}

22            GROUP BY

23                vh.course_id, vh.field_id) AS subquery

24        INNER JOIN

25            fields f

26        ON

27            subquery.field_id = f.field_id;

28    </select>

29</mapper>

 1/**

 2 * 学習履歴リスト作成Service

 3 */

 4@Slf4j

 5@Service

 6public class ViewHistoryService {

 7 

 8    private final ViewHistoryMapper viewHistoryMapper;

 9 

10    // コンストラクタインジェクションを使用

11    @Autowired

12    public ViewHistoryService(ViewHistoryMapper viewHistoryMapper) {

13        this.viewHistoryMapper = viewHistoryMapper;

14    }

15 

16    /**

17     * 指定されたユーザーID、コースID、期間に基づいて分野別に最大進捗率を取得する。

18     *

19     * @param userId   ユーザーID

20     * @param courseId コースID

21     * @return 学習履歴（分野別に最大進捗率）のリスト

22     */

23    @Transactional(readOnly = true)

24    public List<ViewHistoryEntity> getViewHistoryWithMaxProgress(Integer userId, Integer courseId) {

25        // 週の開始日と終了日を計算

26        LocalDateTime startOfWeek = DateUtils.getStartOfWeek();

27        LocalDateTime endOfWeek = DateUtils.getEndOfWeek();

28 

29        log.debug("ユーザーID {} のコースID {} の学習履歴と最大進捗率を週の範囲 {} - {} で取得します。", userId, courseId, startOfWeek, endOfWeek);

30 

31        // データベースから分野別の最大進捗率を直接返す

32        return viewHistoryMapper.getViewHistoryWithMaxProgress(userId, courseId, startOfWeek, endOfWeek);

33    }

34}

 1/**

 2 * 分野別の最大進捗率を取得.

 3 * <h3>機能概要</h3>

 4 * ユーザーIDおよびコースIDに基づいて分野別の最大進捗率を取得し、ViewHistoryResponseFormに詰めて返却する。

 5 *

 6 * <h3>処理フロー</h3>

 7 * 1. リクエストデータのバリデーション<br>

 8 * 2. サービスクラスを呼び出して、最大進捗率を取得<br>

 9 * 3. 進捗率が見つからない場合はエラーメッセージを設定<br>

10 * 4. 最大進捗率またはエラーメッセージリストを返却

11 *

12 * @param form    UserIdForm

13 * @param result  バリデーション結果やエラーを格納

14 * @return 最大進捗率リスト ViewHistoryResponseForm

15 */

16@PostMapping("/top/getViewHistory")

17public ViewHistoryResponseForm getViewHistory(

18        @RequestBody @Validated({ ValidationGroups.Step1.class, ValidationGroups.Step2.class }) UserIdForm form,

19        BindingResult result) {

20    log.debug("TopRest (getViewHistory) 呼び出し開始");

21 

22    ViewHistoryResponseForm responseForm = new ViewHistoryResponseForm();

23    List<String> errorMessageList = new ArrayList<>();

24 

25    // バリデーションエラーがある場合、詳細なエラーメッセージを追加

26    if (result.hasErrors()) {

27        for (FieldError fieldError : result.getFieldErrors()) {

28            String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault());

29            errorMessageList.add(errorMessage);

30        }

31        responseForm.setErrorMessageList(errorMessageList);

32        return responseForm;

33    }

34 

35    Integer userId = Integer.parseInt(form.getUserId());

36    Integer courseId = form.getCourseId();

37 

38    // 最大進捗率のリストを取得

39    List<ViewHistoryEntity> viewHistoryList = viewHistoryService.getViewHistoryWithMaxProgress(userId, courseId);

40 

41    // リストが取得できなかった場合

42    if (CollectionUtils.isEmpty(viewHistoryList)) {

43        errorMessageList

44                .add(messageSource.getMessage(ErrorMessages.VIEW_HISTORY_NOT_FOUND, null, Locale.getDefault()));

45        responseForm.setErrorMessageList(errorMessageList);

46        log.debug("ViewHistoryList (viewHistoryList) 学習履歴が見つかりません: ");

47        return responseForm;

48    }

49    responseForm.setViewHistoryList(viewHistoryList);

50    log.debug("TopRest (getViewHistory) 呼び出し終了");

51 

52    return responseForm;

53}

 1package jp.co.smsdatatech.questiongenerate.entity;

 2 

 3import java.io.Serializable;

 4import java.sql.Timestamp;

 5import lombok.Data;

 6 

 7/**

 8 *

 9 * ExerciseRecordsテーブルEntity

10 */

11@Data

12public class ExerciseRecordsEntity implements Serializable {

13    /** シリアルバージョンUID */

14    private static final long serialVersionUID = 1L;

15 

16    /** ユーザーID */

17    private Integer userId;

18 

19    /** コースID */

20    private Integer courseId;

21 

22    /** 演習開始日時 */

23    private Timestamp startDate;

24 

25    /** 作成日 */

26    private Timestamp createDate;

27 

28    /** 更新日 */

29    private Timestamp updateDate;

30}

 1<?xml version="1.0" encoding="UTF-8"?>

 2<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

 3<mapper namespace="jp.co.smsdatatech.questiongenerate.repository.ExerciseRecordsMapper">

 4    <select id="getTotalLearning" resultType="java.math.BigDecimal">

 5        SELECT

 6            SUM(EXTRACT(EPOCH FROM (end_time - start_time)) / 3600) AS totalLearningTime

 7        FROM

 8            exercise_records

 9        WHERE

10            user_id = #{userId}

11            AND course_id = #{courseId}

12            AND start_time BETWEEN #{startOfWeek} AND #{endOfWeek}

13    </select>

14</mapper>

 1import lombok.extern.slf4j.Slf4j;

 2 

 3/**

 4 * 演習履歴テーブルService

 5 */

 6@Slf4j

 7@Service

 8public class ExerciseRecordsService {

 9 

10    private final ExerciseRecordsMapper exerciseRecordsMapper;

11 

12    // コンストラクタインジェクションを使用

13    @Autowired

14    public ExerciseRecordsService(ExerciseRecordsMapper exerciseRecordsMapper) {

15        this.exerciseRecordsMapper = exerciseRecordsMapper;

16    }

17 

18    /**

19     * ユーザーIDとコースIDを基に、週の範囲内で合計学習時間を取得する。

20     *

21     * @param userId   ユーザーID

22     * @param courseId コースID

23     * @return 総学習時間

24     */

25    @Transactional(readOnly = true)

26    public BigDecimal getTotalLearningTime(Integer userId, Integer courseId) {

27 

28        // 週の開始日と終了日を計算

29        LocalDateTime startOfWeek = DateUtils.getStartOfWeek();

30        LocalDateTime endOfWeek = DateUtils.getEndOfWeek();

31 

32        log.debug("ユーザーID {} とコースID {} の合計学習時間を週の範囲 {} - {} で取得します。", userId, courseId, startOfWeek, endOfWeek);

33        return exerciseRecordsMapper.getTotalLearning(userId, courseId, startOfWeek, endOfWeek);

34    }

35}

 1/**

 2 * 総学習時間を取得.

 3 * <h3>機能概要</h3>

 4 * ユーザーIDおよびコースIDに基づいて総学習時間を取得し、TotalLearningTimeResponseFormに詰めて返却する。

 5 *

 6 * <h3>処理フロー</h3>

 7 * 1. リクエストデータのバリデーション<br>

 8 * 2. サービスクラスを呼び出して、総学習時間を取得<br>

 9 * 3. 学習時間が見つからない場合はエラーメッセージを設定<br>

10 * 4. 総学習時間またはエラーメッセージリストを返却

11 *

12 * @param form    UserIdForm

13 * @param result  バリデーション結果やエラーを格納

14 * @return 総学習時間リスト TotalLearningTimeResponseForm

15 */

16@PostMapping("/top/getTotalLearningTime")

17public TotalLearningTimeResponseForm getTotalLearningTime(

18        @RequestBody @Validated({ ValidationGroups.Step1.class, ValidationGroups.Step2.class }) UserIdForm form,

19        BindingResult result) {

20    log.debug("TopRest (getTotalLearningTime) 呼び出し開始");

21 

22    TotalLearningTimeResponseForm responseForm = new TotalLearningTimeResponseForm();

23    List<String> errorMessageList = new ArrayList<>();

24 

25    // バリデーションエラーがある場合、詳細なエラーメッセージを追加

26    if (result.hasErrors()) {

27        for (FieldError fieldError : result.getFieldErrors()) {

28            String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault());

29            errorMessageList.add(errorMessage);

30        }

31        responseForm.setErrorMessageList(errorMessageList);

32        return responseForm;

33    }

34 

35    Integer userId = Integer.parseInt(form.getUserId());

36    Integer courseId = form.getCourseId();

37 

38    // サービスで合計学習時間を取得（学習時間がない場合はデフォルト値0.0)

39    BigDecimal totalLearningTime = exerciseRecordsService.getTotalLearningTime(userId, courseId);

40    if (totalLearningTime == null) {

41        totalLearningTime = BigDecimal.ZERO;

42    }

43 

44    responseForm.setTotalLearningTime(totalLearningTime);

45    log.debug("TopRest (getTotalLearningTime) 呼び出し終了");

46 

47    return responseForm;

48}

 1package jp.co.smsdatatech.questiongenerate.entity;
 2 
 3import java.io.Serializable;
 4import java.sql.Timestamp;
 5 
 6import lombok.Data;
 7 
 8/**
 9 * ログイン履歴テーブルEntity
10 */
11@Data
12public class LoginHistoryEntity implements Serializable {
13 
14    /** シリアルバージョンUID */
15    private static final long serialVersionUID = 1L;
16 
17    /** ユーザーID */
18    private Integer userId;
19 
20    /** 法人ID */
21    private Integer corporateId;
22 
23    /** ログイン日時 */
24    private Timestamp loginDate;
25}

 1<mapper namespace="jp.co.smsdatatech.questiongenerate.repository.LoginHistoryMapper">
 2 
 3    <select id="getLoginHistoryByUserIdAndDateRange" parameterType="map" resultType="java.time.LocalDateTime">
 4        SELECT DISTINCT
 5            login_date
 6        FROM
 7            login_history
 8        WHERE
 9            user_id = #{userId}
10            AND login_date BETWEEN #{startOfWeek} AND #{endOfWeek}
11        ORDER BY
12            login_date DESC
13    </select>
14</mapper>

 1public class LoginHistoryService {
 2 
 3    /**
 4     * 指定されたユーザーIDに基づいてログイン履歴を取得する。
 5     *
 6     * @param userId ユーザーID
 7     * @return ログイン履歴（曜日ごとの情報）
 8     */
 9    @Transactional(readOnly = true)
10    public Map<String, Boolean> getLoginHistoryByUserIdAndDateRange(Integer userId) {
11        // 週の開始日と終了日を計算
12        LocalDateTime startOfWeek = DateUtils.getStartOfWeek();
13        LocalDateTime endOfWeek = DateUtils.getEndOfWeek();
14 
15        log.debug("ユーザーID {} のログイン履歴を週の範囲 {} - {} で取得します。", userId, startOfWeek, endOfWeek);
16 
17        // データベースからログイン履歴を取得
18        List<LocalDateTime> loginHistory = loginHistoryMapper.getLoginHistoryByUserIdAndDateRange(userId, startOfWeek, endOfWeek);
19 
20        Map<String, Boolean> dailyLoginHistoryMap = DateUtils.initializeWeekMap();
21 
22        DateTimeFormatter dayFormatter = DateTimeFormatter.ofPattern("EEEE", Locale.ENGLISH);
23        for (LocalDateTime login : loginHistory) {
24            if (login != null) {
25                String dayOfWeek = login.format(dayFormatter).toLowerCase(Locale.ROOT);
26                dailyLoginHistoryMap.put(dayOfWeek, true);
27            }
28        }
29        return dailyLoginHistoryMap;
30    }
31}

 1public class TopRest {
 2 
 3    /**
 4     * ログイン状況取得.
 5     *
 6     * login_historyテーブルからユーザーIDに紐づくログイン状況を取得し、LoginHistoryResponseFormに詰めて返却する。
 7     *
 8     * <h3>処理フロー</h3>
 9     * 1. ログイン履歴を取得<br>
10     * 2. 取得データを返却
11     *
12     * <h3>レスポンス構成</h3>
13     * - **loginHistoryByDay**: 曜日ごとのログイン状況（キー: 曜日、値: true/false）<br>
14     * - **error**: エラー発生時のメッセージ
15     *
16     * @param form    Top画面UserId用Form
17     * @param result  バリデーション結果
18     * @return ログイン履歴情報 LoginHistoryResponseForm
19     */
20    @PostMapping("/top/getLoginHistoryByUserId")
21    public LoginHistoryResponseForm getLoginHistoryByUserId(@RequestBody @Valid UserIdForm form, BindingResult result) {
22        List<String> errorMessageList = new ArrayList<>();
23        LoginHistoryResponseForm responseForm = new LoginHistoryResponseForm();
24 
25        Set<String> processedFields = new HashSet<>();
26 
27        // バリデーションエラーがある場合、詳細なエラーメッセージを追加
28        if (result.hasErrors()) {
29            for (FieldError fieldError : result.getFieldErrors()) {
30                // フィールド名を基に重複チェック
31                if (!processedFields.contains(fieldError.getField())) {
32                    String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault());
33                    errorMessageList.add(errorMessage);
34                    processedFields.add(fieldError.getField());
35                }
36            }
37            responseForm.setErrorMessageList(errorMessageList);
38            return responseForm;
39        }
40 
41        // ユーザーIDを整数に変換
42        Integer userId = Integer.parseInt(form.getUserId());
43 
44        // サービス層で曜日ごとのログイン履歴を取得
45        Map<String, Boolean> dailyLoginHistoryMap = loginHistoryService.getLoginHistoryByUserIdAndDateRange(userId);
46 
47        // ログイン履歴が空かどうかをチェック
48        if (dailyLoginHistoryMap.isEmpty()) {
49            errorMessageList.add(messageSource.getMessage(ErrorMessages.NO_LOGIN_HISTORY, null, Locale.getDefault()));
50            responseForm.setErrorMessageList(errorMessageList);
51            return responseForm;
52        }
53 
54        responseForm.setDailyLoginHistoryMap(dailyLoginHistoryMap);
55        return responseForm;
56    }
57}

 1public class DateUtils {
 2 
 3    /** 曜日をまとめた配列 */
 4    protected static final String[] DAYS_OF_WEEK = {
 5            "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"
 6    };
 7 
 8    /**
 9     * プライベートコンストラクタでインスタンス化を禁止する
10     */
11    private DateUtils() {
12        throw new UnsupportedOperationException("このクラスはインスタンス化できません");
13    }
14 
15    /**
16     * 指定された日付の週の開始日（月曜日の00:00:00）を取得.
17     *
18     * @param date 基準日
19     * @return 週の開始日
20     */
21    public static LocalDateTime getStartOfWeek(LocalDate date) {
22        return date.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)).atStartOfDay();
23    }
24 
25    /**
26     * 現在週の開始日（月曜日の00:00:00）を取得.
27     *
28     * @return 現在週の開始日
29     */
30    public static LocalDateTime getStartOfWeek() {
31        return getStartOfWeek(LocalDate.now());
32    }
33 
34    /**
35     * 指定された日付の週の終了日（日曜日の23:59:59）を取得.
36     *
37     * @param date 基準日
38     * @return 週の終了日
39     */
40    public static LocalDateTime getEndOfWeek(LocalDate date) {
41        return date.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY)).atTime(LocalTime.MAX);
42    }
43 
44    /**
45     * 現在週の終了日（日曜日の23:59:59）を取得.
46     *
47     * @return 現在週の終了日
48     */
49    public static LocalDateTime getEndOfWeek() {
50        return getEndOfWeek(LocalDate.now());
51    }
52 
53    /**
54     * 曜日ごとの初期マップを作成（初期値はすべてfalse）.
55     *
56     * @return 曜日をキーにしたマップ（値はすべてfalse）
57     */
58    public static Map<String, Boolean> initializeWeekMap() {
59        Map<String, Boolean> weekMap = new LinkedHashMap<>();
60        for (String day : DAYS_OF_WEEK) {
61            weekMap.put(day, false);
62        }
63        return weekMap;
64    }
65}

{
  "corporateId": 1
}

{
    "errorMessageList": null,
    "courseList": [
        {
            "course_id": 1,
            "corporate_id": 1,
            "course_name": "プログラミング基礎",
            "create_date": "2024-06-01T01:00:00.000+00:00",
            "update_date": "2024-06-01T01:00:00.000+00:00"
        },
        {
            "course_id": 2,
            "corporate_id": 1,
            "course_name": "データベース管理",
            "create_date": "2024-06-15T00:00:00.000+00:00",
            "update_date": "2024-06-15T00:00:00.000+00:00"
        }
    ]
}

package jp.co.smsdatatech.questiongenerate.entity;

import java.io.Serializable;
import java.sql.Timestamp;

import jakarta.persistence.Column;
import lombok.Data;

/**
 * courseテーブルEntity
 */
@Data
public class CourseEntity implements Serializable {

    /** シリアルバージョンUID */
    private static final long serialVersionUID = 1L;

    /** コースID */
    private Integer course_id;

    /** 法人ID */
    private Integer corporate_id;

    /** コース名 */
    private String course_name;

    /** 作成日 */
    private Timestamp create_date;

    /** 更新日 */
    private Timestamp update_date;
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="jp.co.smsdatatech.questiongenerate.repository.CourseMapper">
    <select id="getAllByCorporateId" parameterType="Integer" resultType="jp.co.smsdatatech.questiongenerate.entity.CourseEntity">
        SELECT
            course_id,
            corporate_id,
            course_name,
            create_date,
            update_date
        FROM
            course
        WHERE
            corporate_id = #{corporateId}
        ORDER BY
            course_id
    </select>
</mapper>

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import jp.co.smsdatatech.questiongenerate.entity.CourseEntity;
import jp.co.smsdatatech.questiongenerate.repository.CourseMapper;

/**
 * コーステーブルService
 */
@Service
public class CourseService {

    /** ログ出力クラス */
    private static final Logger log = LoggerFactory.getLogger(clazz:CourseService.class);

    /** courseテーブルMapper */
    @Autowired
    private CourseMapper courseMapper;

    /**
     * コース検索（法人ID検索）
     * 1.機能概要
     * courseテーブルから法人IDに紐づくコースを取得し、Listで返却する。
     * 2.処理フロー
     * ①DB接続・抽出
     * ②返却
     *
     * @param corporateId 法人ID
     * @return {@literal List<CourseEntity> コース一覧}
     */
    public List<CourseEntity> getAllByCorporateId(Integer corporateId) {
        List<CourseEntity> courseList = courseMapper.getAllByCorporateId(corporateId);
        log.info("courseテーブルから法人ごとのレコードを取得しました。");
        return courseList;
    }
}

/**
 * コースリスト取得.
 *
 * 法人IDに紐づくコースリストを取得し、CorporateCourseResponseForm に詰めて返却する。
 *
 * <h3>処理フロー</h3>
 * 1. コース情報（コースIDとコース名）を取得<br>
 * 2. 取得したリストを返却
 *
 * @param form Top画面Form
 * @param result バリデーション結果
 * @return コースリスト CorporateCourseResponseForm
 */
@PostMapping("/top/getCourseListByCorporateId")
public CorporateCourseResponseForm getCourseListByCorporateId(@RequestBody @Valid TopForm form,
        BindingResult result) {
    log.debug("TopRest (getCourseListByCorporateId) 呼び出し開始");

    CorporateCourseResponseForm responseForm = new CorporateCourseResponseForm();
    List<String> errorMessageList = new ArrayList<>();

    Set<String> processedFields = new HashSet<>();

    // バリデーションエラーがある場合、詳細なエラーメッセージを追加
    if (result.hasErrors()) {
        for (FieldError fieldError : result.getFieldErrors()) {
            // フィールド名を基に重複チェック
            if (!processedFields.contains(fieldError.getField())) {
                String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault());
                errorMessageList.add(errorMessage);
                processedFields.add(fieldError.getField());
            }
        }
        responseForm.setErrorMessageList(errorMessageList);
        return responseForm;
    }

    // 法人IDを整数に変換
    Integer corporateId = Integer.parseInt(form.getCorporateId());

    // 法人IDを基にコースリストを取得
    List<CourseEntity> courseList = courseService.getAllByCorporateId(corporateId);

    if (CollectionUtils.isEmpty(courseList)) {
        // コースが見つからなかった場合
        errorMessageList.add(messageSource.getMessage(ErrorMessages.COURSE_NOT_FOUND, args:null, Locale.getDefault()));
        responseForm.setErrorMessageList(errorMessageList);
        log.debug("CourseRest (getCourseList) コースが見つかりません: ");
        return responseForm;
    }

    // コースリストをレスポンスに設定
    responseForm.setCourseList(courseList);
    return responseForm;
}

{
  "mailAddress": "[email protected]"
}

{
  "userId": 175,
  "corporateId": 1,
  "errorMessageList": null
}

package jp.co.smsdatatech.questiongenerate.entity;

import java.io.Serializable;
import java.sql.Timestamp;
import lombok.Data;

/**
 * ログイン履歴テーブルEntity
 */
@Data
public class LoginHistoryEntity implements Serializable {

    /** シリアルバージョンUID */
    private static final long serialVersionUID = 1L;

    /** ユーザーID */
    private Integer userId;

    /** 法人ID */
    private Integer corporateID;

    /** ログイン日時 */
    private Timestamp loginDate;
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="jp.co.smsdatatech.questiongenerate.repository.CustomerMapper">

  <select id="getByMailAddress"
          parameterType="String"
          resultType="jp.co.smsdatatech.questiongenerate.entity.CustomerEntity">
    SELECT
      user_id,
      user_name,
      mail_address,
      address_prefecture,
      address_municipality,
      birthday,
      gender,
      create_date,
      update_date
    FROM
      customer
    WHERE
      mail_address = #{mailAddress}
  </select>

</mapper>

import lombok.extern.slf4j.Slf4j;
import jp.co.smsdatatech.questiongenerate.util.DateUtils;

/**
 * ログイン履歴テーブルサービス
 */
@Slf4j
@Service
public class LoginHistoryService {

    private final LoginHistoryMapper loginHistoryMapper;

    // コンストラインジェクションを使用
    @Autowired
    public LoginHistoryService(LoginHistoryMapper loginHistoryMapper) {
        this.loginHistoryMapper = loginHistoryMapper;
    }

    /**
     * 指定されたメールアドレスに基づいてユーザー情報を取得する。
     *
     * @param email メールアドレス
     * @return ユーザーIDと法人IDを含むリスト。
     */
    @Transactional(readOnly = true)
    public Map<String, Object> getUserDetailsByEmail(String email) {
        log.debug("format: メールアドレス {} に基づくユーザー情報を取得します。", email);
        return loginHistoryMapper.getUserDetailsByEmail(email);
    }

public class TopRest {

    /**
     * ログイン状況取得。
     *
     *<p>login_historyテーブルからユーザーIDに基づくログイン状況を取得し、
     * LoginHistoryResponseFormに詰めて返却する。
     *
     *<h3>処理フロー</h3>
     * 1. ログイン履歴を取得
     * 2. 取得データを返却
     *
     *<h3>レスポンス構成</h3>
     * "loginHistorysByDay" -> 曜日ごとのログイン状況 (キー：曜日, 値：true/false)
     * "error" -> エラー発生時のメッセージ
     *
     *@param form Top画面UserId用form
     *@param result バリデーション結果
     *@return ログイン履歴情報 LoginHistoryResponseform
     */
    @PostMapping("/getLoginHistoryByUserId")
    public LoginHistoryResponseForm getLoginHistoryByUserId(
            @RequestBody @Valid UserIdForm form,
            BindingResult result) {

        List<String> errorMessageList = new ArrayList<>();
        LoginHistoryResponseForm responseForm = new LoginHistoryResponseForm();
        Set<String> processedFields = new HashSet<>();

        // バリデーションエラーがある場合、詳細なエラーメッセージを追加
        if (result.hasErrors()) {
            for (FieldError fieldError : result.getFieldErrors()) {
                // フィールド名を基に重複チェック
                if (!processedFields.contains(fieldError.getField())) {
                    String errorMessage = messageSource.getMessage(fieldError, Locale.getDefault());
                    errorMessageList.add(errorMessage);
                    processedFields.add(fieldError.getField());
                }
            }
            responseForm.setErrorMessageList(errorMessageList);
            return responseForm;
        }

        // ユーザーIDを整数に変換
        Integer userId = Integer.parseInt(form.getUserId());

        // サービス層で曜日ごとのログイン履歴を取得
        Map<String, Boolean> dailyLoginHistoryMap =
            loginHistoryService.getLoginHistoryByUserIdAndDateRange(userId);

        // ログイン履歴が空かどうかをチェック
        if (dailyLoginHistoryMap.isEmpty()) {
            errorMessageList.add(messageSource.getMessage(
                ErrorMessages.NO_LOGIN_HISTORY, null, Locale.getDefault()));
            responseForm.setErrorMessageList(errorMessageList);
            return responseForm;
        }

        responseForm.setDailyLoginHistoryMap(dailyLoginHistoryMap);
        return responseForm;
    }

var myLineChart = new Chart(ctx, {
  type: 'doughnut', // グラフの種類
  data: data,       // データ
  options: options // オプション設定
});

createChart(labels, data) {
  let canvas = document.getElementById('learningTimeChart');
  if (canvas) {
    let ctx2 = canvas.getContext('2d');
    if (ctx2) {
      if (this.learningTimeChart) {
        this.learningTimeChart.destroy();
      }

      this.learningTimeChart = new Chart(ctx2, {
        type: 'doughnut',
        data: {
          labels: labels,
          datasets: [{
            data: data,
            backgroundColor: ['#36A2EB', '#FF6384'],
            hoverBackgroundColor: ['#36A2EB', '#FF6384']
          }]
        },
        options: {
          cutout: '0%',
          plugins: {
            legend: {
              display: false
            },
            tooltip: {
              enabled: false
            },
            datalabels: {
              display: false
            }
          }
        }
      });

      this.isLoading = false;
    }
  }
},

"learning_time_data": {
  "labels": ["学習時間", "残りの時間"],
  "data": [200, 120]
},