properties
application.properties
# DB
spring.datasource.driver-class-name=org.postgresql.Driver
spring.datasource.url=jdbc:postgresql://localhost:5432/spring
spring.datasource.username=spring
spring.datasource.password=spring
#DB生成処理
#実行の際にはユーザーとデータベースが作成されている必要あり
spring.sql.init.mode=always
spring.sql.init.schema-locations=classpath:database/schema.sql
spring.sql.init.data-locations=classpath:database/data.sql
#devtoolの設定
spring.devtools.restart.additional-paths=src/main/resources
#ログ
logging.level.org.springframework.web=DEBUG
logging.level.org.hibernate=ERROR
logging.level.web=trace
spring.mvc.log-request-details=true
#Mybatis SQL文 出力
logging.level.jp.co.project.infra.repository=DEBUG
#spring security
server.port=8443
server.ssl.enabled=true
server.ssl.key-alias=tomcat
server.ssl.key-password=keyPassword
server.ssl.key-store=classpath:tomcat.jks
server.ssl.key-store-type=JKS
server.ssl.key-store-password=storePassword
#messages.propertiesの設定
spring.messages.basename=messages,text
server.servlet.session.timeout=180s
messages.propaties
# =======================================
# ログイン失敗メッセージ
# =======================================
AbstractUserDetailsAuthenticationProvider.locked=アカウントはロックされています
AbstractUserDetailsAuthenticationProvider.disabled=アカウントは使用できません
AbstractUserDetailsAuthenticationProvider.expired=アカウントの有効期限が切れています
AbstractUserDetailsAuthenticationProvider.credentialsExpired=パスワードの有効期限が切れています
AbstractUserDetailsAuthenticationProvider.badCredentials=ログインIDまたはパスワードが間違っています
# =======================================
# 共通メッセージ
# =======================================
Already.completed=既に作業は完了しております。
Session.lost=セッションが破棄されております。もう一度作業をし直してください
# =======================================
# ユーザー情報バリデーションメッセージ
# =======================================
User.required=必須項目です
User.blank=空白以外で入力してください
User.blankFirst=文字の先頭が空白になっています
User.blankLast=文字の末尾が空白になっています
User.alphaDigit=半角英数字のみで入力してください
User.half=半角で入力してください
User.mark=英数字と記号は半角で入力してください
User.match={0}が一致しません
User.date=日付形式で入力してください
User.noDate=日付が実在しません
User.FutureDate=日付が明日以降になっています
User.mail=無効なメールアドレスです
User.tel=無効な電話番号です
User.hyphen=ハイフンありで入力してください
User.range={0}文字以上{1}文字以下で入力してください
User.duplicate=入力したログインIDは既に登録されています
User.notChange=更新内容は、修正されておりません
User.optimistic=他のユーザーが、情報を更新した可能性があります。情報を確認したうえ、作業をやり直し願います
text.propaties
# =======================================
# ラベル
# =======================================
label.add=登録
label.update=更新
label.delete=削除
# =======================================
# アクション
# =======================================
action.add=add
action.update=update
action.delete=delete
# =======================================
# ユーザー権限名
# =======================================
authority.admin=管理者
authority.general=一般
Repository~Service
UserEntity.java
/**
* ログインID
*/
private String userId;
/**
* ユーザー名
*/
private String userName;
/**
* パスワード
*/
private String password;
/**
* パスワード更新日時
*/
private Timestamp passUpdateDate;
/**
* 性別
*/
private String gender;
/**
* 生年月日
*/
private String birthday;
/**
* 連絡先
*/
private String contact;
/**
* メールアドレス
*/
private String mailAddress;
/**
* ログイン失敗回数
*/
private int loginMissTimes;
/**
* ロック状態
*/
private boolean unlock;
/**
* ユーザー有効無効
*/
private boolean enabled;
/**
* ユーザー有効期限
*/
private Timestamp userDueDate;
/**
* 登録日時
*/
private Timestamp insertDate;
/**
* 更新日時
*/
private Timestamp updateDate;
/**
* UserEntity toString
*/
// toString()で文字列に変換することでデータベースの値を複数の人が変更しているときに誰かが変更した値を上書きしてしまわないようにtoString()で文字列にしておくことで
// 「変更前の値（変更しようとしていた値）」とは違うということをメッセージなどでわかるようにするためのもの
public String toString() {
String str = this.userId
+ "," + userName
+ "," + password
+ "," + (passUpdateDate == null ? "null" : passUpdateDate.toString())
+ "," + gender
+ "," + birthday
+ "," + contact
+ "," + mailAddress
+ "," + loginMissTimes
+ "," + (userDueDate == null ? "null" : userDueDate.toString())
+ "," + (insertDate == null ? "null" : insertDate.toString())
+ "," + (updateDate == null ? "null" : updateDate.toString())
;
return str;
}
// public boolean getUnlock() {
// return unlock;
// }
}
UserRepository.java
@Repository
@Mapper
public interface UserRepository {
/**
* ユーザー情報 全件件検索
* @return
*/
public List<UserEntity> findAll();
/**
* ユーザー情報 主キー検索
* @param String userId
* @return UserEntity
*/
public UserEntity findByUserId(String userId);
/**
* ユーザー情報 重複検索
* @param String userId
* @return UserEntity
*/
public List<UserEntity> getUserIdByUserId(String userId);
/**
* ユーザー情報 登録
* @param UserEntity entity
* @return int
*/
public int insert(UserEntity entity);
/**
* ユーザー情報 更新
* @param UserEntity entity
* @return int
*/
public int update(UserEntity entity);
/**
* ユーザー情報 アカウントロックステータス 更新
* @param boolean unlock true:ロック解除 false:ロック中
* @param String userId
* @return int
*/
//public int updateUnlock(@Param("unlock") boolean unlock, @Param("userId") String userId);
/**
* ユーザー情報 有効ステータス 更新
* @param boolean enabled true:アカウント有効 false:アカウント無効
* @param String userId
* @return int
*/
//public int updateEnabled(@Param("enabled") boolean enabled, @Param("userId") String userId);
/**
* ユーザー情報 削除
* @param String userId
* @return int
*/
public int delete(String userId);
}
UserRepository.xml
<?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.****.infra.repository.user.UserRepository">
<resultMap
type="jp.co.****.infra.repository.user.UserEntity" id="user">
<id property="userId" column="user_id" />
<result property="userName" column="user_name" />
<result property="password" column="password" />
<result property="passUpdateDate" column="pass_update_date" />
<result property="gender" column="gender" />
<result property="birthday" column="birthday" />
<result property="contact" column="contact" />
<result property="mailAddress" column="mail_address" />
<result property="loginMissTimes" column="login_miss_times" />
<result property="unlock" column="unlock" />
<result property="enabled" column="enabled" />
<result property="userDueDate" column="use_due_date" />
<result property="insertDate" column="insert_date" />
<result property="updateDate" column="update_date" />
</resultMap>
<select id="findAll" resultMap="user">
select
user_id
, user_name
,
password
, pass_update_date
, gender
, birthday
, contact
,
mail_address
,
login_miss_times
, unlock, tenant_id
, enabled,
user_due_date
,
insert_date, update_date
from m_user
order by insert_date
asc
</select>
<select id="findByUserId" resultMap="user">
select
user_id
, user_name
,
password
, pass_update_date
, gender
, birthday
, contact
,
mail_address
,
login_miss_times
, unlock
, tenant_id
, enabled
,
user_due_date
,
insert_date
, update_date
from public.m_user
where
user_id=#{userId};
</select>
<select id="getUserIdByUserId" resultMap="user">
select
user_id
,
user_name
,
password
, pass_update_date
, gender
, birthday
,
contact
,
mail_address
,
login_miss_times
, unlock
, tenant_id
, enabled
,
user_due_date
,
insert_date
, update_date
from public.m_user
where
user_id=#{userId};
</select>
<insert id="insert">
insert into m_user (
user_id
, user_name
, password
,
pass_update_date
, gender
, birthday
, contact
, mail_address
,
login_miss_times
, unlock
, enabled
, user_due_date
,
insert_date
) values (
#{userId}
, #{userName}
, #{password}
, #{passUpdateDate}
, #{gender}
,
#{birthday}
, #{contact}
, #{mailAddress}
, #{loginMissTimes}
, #{unlock}
, #{enabled}
, #{userDueDate}
, NOW()
)
</insert>
<update id="update">
update m_user set
<if test="userName != null">
user_name=#{userName},
</if>
<if test="password != null">
password=#{password},
</if>
<if test="passUpdateDate != null">
pass_update_date=NOW(),
</if>
<if test="gender != null">
gender=#{gender},
</if>
<if test="birthday != null">
birthday=#{birthday},
</if>
<if test="contact != null">
contact=#{contact},
</if>
<if test="mailAddress != null">
mail_address=#{mailAddress},
</if>
unlock=#{unlock},
enabled=#{enabled},
<if test="userDueDate != null">
user_due_date=#{userDueDate},
</if>
update_date=NOW()
where user_id=#{userId}
</update>
<update id="updateUnlock">
update m_user set
unlock=#{unlock}
,update_date=NOW()
where user_id=#{userId}
</update>
<update id="updateEnabled">
update m_user set
enabled=#{enabled}
,
update_date=NOW()
where user_id=#{userId}
</update>
<delete id="delete">
delete from m_user
where user_id = #{userId};
</delete>
</mapper>
UserRoleEntity.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserRoleEntity {
// t_user_role テーブルのid
//private int id;
private String userId;
private String roleId;
}
UserRoleRepository.java
@Repository
@Mapper
public interface UserRoleRepository {
/**
* ユーザー権限関連情報 全件検索
*
* @return List<UserRoleEntity>
*/
// findAllなのでリストを返す
public List<UserRoleEntity> findAll();
/*
* ユーザー権限関連情報 ユーザーID指定検索 連想配列型で返す
*
* @param userId
*
* @return List<Map<String, Object>>
*/
public List<Map<String, Object>> findRoleIdByUserId(String username); // 型違い
/*
* 検索用の SQL は、<select> タグで宣言する。 id 属性で、その SQL を参照するための識別名を設定する。 resultType
* 属性で、検索結果のレコードをどの型にマッピングするかを定義する。 ここでは map と指定しているので、 Map 型に変換される。→
* Map<String, Object> 検索結果が複数のレコードを返す場合、SqlSession の selectList() メソッドを使用する。
* 戻り値は List 型になる。→ List<Map<String, Object>>
*/
/**
* ユーザー権限関連情報（ID, ユーザーID, 権限ID） ユーザーID指定検索 リスト型で返す
*
* @param userId
* @return List<UserRoleEntity>
*/
public List<UserRoleEntity> findByUserId(String userId);
/**
* ユーザー権限関連情報 ロールID指定検索
*
* @param roleId
* @return List<UserRoleEntity>
*/
public List<UserRoleEntity> findByRoleId(String roleId);
/**
* ユーザー権限関連情報 登録 ユーザー情報が登録されるとき、同一ユーザーの権限情報も登録する
*
* @param userRoleEntity
* @return int
*/
public boolean insert(UserRoleEntity userRoleEntity);
/**
* ユーザー権限関連情報 更新 ユーザー情報が更新されるとき、同一ユーザーの権限情報も更新する
*
* @param userRoleEntity
* @return int
*/
// public int update(UserRoleEntity userRoleEntity);
// 静的パターン
// public int updateUserId(String beforeUserId, String afterUserId);
// public int updateRoleId(String beforeRoleId, String afterRoleId);
// 動的パターン
public int update(@Param("afterEntity") List<UserRoleEntity> afterUserRoleEntity,
@Param("beforeEntity") List<UserRoleEntity> beforeUserRoleEntity);
/**
* ユーザー権限関連情報 削除 条件 主キーによる限定 ユーザー情報が削除されるとき、同一ユーザーの権限情報も削除する
*
* @param userRoleEntity
* @return int
*/
// 削除処理用デリート文
public int delete(String userId);
// 更新処理用デリート文
public boolean updateDelete(UserRoleEntity userRoleEntity);
}
// もし権限の増減があるなら 論理削除への変更の可能性あり
// ロールID指定で検索したリストサイズが0の時、権限の削除が可能になる
// リストが0じゃない限りは「削除不可」のメッセージを出す ようにすべき？
UserDtoHelper.java
@Component
public class UserDtoHelper {
@Autowired
ModelMapper modelMapper;
/**
* EntityからDtoへ変換処理
*
* @param entity
* @return
*/
public UserDto mapToUserDto(UserEntity entity) {
// マップ先が曖昧な場合は無視
modelMapper.getConfiguration().setAmbiguityIgnored(true);
UserDto userDto = modelMapper.map(entity, UserDto.class);
return userDto;
}
/**
* List<UserEntity>からList<UserDto>へ変換処理
*
* @param userEntity
* @param entityList
* @return
*/
public List<UserDto> mapToUserDtoList(List<UserEntity> entityList) {
List<UserDto> dtoList = new ArrayList<UserDto>();
for (UserEntity entity : entityList) {
UserDto userDto = this.mapToUserDto(entity);
dtoList.add(userDto);
}
return dtoList;
}
/**
*DtoからEntityへ変換処理
* @param dto
* @return
*/
public UserEntity mapToUserEntity(UserDto dto) {
//マップ先が曖昧な場合は無視
modelMapper.getConfiguration().setAmbiguityIgnored(true);
UserEntity userEntity = modelMapper.map(dto, UserEntity.class);
return userEntity;
}
/**
* List<UserDto>からList<UserEntity>へ変換処理
*
* @param userDto
* @param dtoList
* @return
*/
public List<UserEntity> mapToUserEntityList(List<UserDto> dtoList) {
List<UserEntity> entityList = new ArrayList<UserEntity>();
for (UserDto dto : dtoList) {
UserEntity userEntity = mapToUserEntity(dto);
entityList.add(userEntity);
}
return entityList;
}
}
UserRoleRepository.xml
<?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.****.infra.repository.userrole.UserRoleRepository">
<resultMap id="userRoleMap"
type="jp.co.****.infra.repository.userrole.UserRoleEntity">
<!-- <id property="id" column="id" /> -->
<id property="userId" column="user_id" />
<id property="roleId" column="role_id" />
<!-- <id property="roleName" column="role_name" /> -->
</resultMap>
<select id="findAll" resultMap="userRoleMap">
select
<!-- tur.id, -->
tur.user_id,
tur.role_id
from
t_user_role tur
<!-- inner join -->
<!-- m_role mr -->
<!-- on -->
<!-- tur.role_id = mr.role_id -->
order by
tur.role_id asc
;
</select>
<select id="findRoleIdByUserId" resultType="java.util.Map">
select
ro.role_name as
roleName
from
t_user_role tur
inner join
m_role ro
on
tur.role_id =
ro.role_id
where
user_id=#{userId}
</select>
<select id="findByUserId" resultMap="userRoleMap">
select
<!-- tur.id, -->
tur.user_id,
tur.role_id
from
t_user_role tur
<!-- inner join -->
<!-- m_role mr -->
<!-- on -->
<!-- tur.role_id = mr.role_id -->
where
tur.user_id = #{userId}
order by tur.id asc
;
</select>
<select id="findByRoleId" resultMap="userRoleMap">
select
<!-- tur.id, -->
tur.user_id,
tur.role_id
from
t_user_role tur
<!-- left outer join -->
<!-- m_role mr -->
<!-- on -->
<!-- tur.role_id = mr.role_id -->
where
tur.role_id = #{roleId}
order by tur.id asc
;
</select>
<insert id="insert">
insert
into
t_user_role
(
user_id
,role_id
)select
#{userId}
,#{roleId}
where not exists(
select user_id, role_id from
t_user_role where user_id =
#{userId} and role_id =#{roleId})
;
</insert>
<update id="update">
update
t_user_role
<choose>
<when
test="afterEntity.userId != null and beforeEntity.userId != null and afterEntity.roleId == null and beforeEntity.roleId == null">
set
user_id = #{afterEntity.userId}
where
user_id =
#{beforeEntity.userId}
</when>
<when
test="afterEntity.userId == null and beforeEntity.userId == null and afterEntity.roleId != null and beforeEntity.roleId != null">
set
role_id = #{afterEntity.roleId}
where
role_id =
#{beforeEntity.roleId}
</when>
<otherwise>
</otherwise>
</choose>
<!-- update -->
<!-- t_user_role -->
<!-- set -->
<!-- <choose> -->
<!-- <when test="afterEntity.userId != beforeEntity.userId "> -->
<!-- user_id = #{afterEntity.userId} -->
<!-- </when> -->
<!-- <when test="afterEntity.roleId != beforeEntity.roleId "> -->
<!-- role_id = #{afterEntity.roleId} -->
<!-- </when> -->
<!-- </choose> -->
<!-- where -->
<!-- id= #{beforeEntity.id} -->
</update>
<delete id="delete">
delete
from
t_user_role
where
user_id =
#{userId}
;
</delete>
<delete id="updateDelete">
delete
from
t_user_role
where
user_id =
#{userId}
and
role_id!=
#{roleId}
;
</delete>
</mapper>
UserRoleDtoHelper.java
@Component
public class UserRoleDtoHelper {
@Autowired
ModelMapper modelMapper;
/**
*
* @param entity
* @return
*/
public UserRoleDto mapToUserRoleDto(UserRoleEntity entity) {
//マップ先があいまいな場合は無視
modelMapper.getConfiguration().setAmbiguityIgnored(true);
UserRoleDto dto = modelMapper.map(entity, UserRoleDto.class);
return dto;
}
/**
*
* @param entityList
* @return
*/
public List<UserRoleDto> mapToUserRoleDtoList(List<UserRoleEntity> entityList) {
List<UserRoleDto> dtoList = new ArrayList<UserRoleDto>();
for (UserRoleEntity entity : entityList) {
UserRoleDto userRoleDto = mapToUserRoleDto(entity);
dtoList.add(userRoleDto);
}
return dtoList;
}
/**
*
* @param dto
* @return
*/
public UserRoleEntity mapToUserRoleEntity(UserRoleDto dto) {
//マップが曖昧な場合は無視
modelMapper.getConfiguration().setAmbiguityIgnored(true);
UserRoleEntity entity = modelMapper.map(dto, UserRoleEntity.class);
return entity;
}
/**
*
* @param dtoList
* @return
*/
public List<UserRoleEntity> mapToUserRoleEntityList(List<UserRoleDto> dtoList) {
List<UserRoleEntity> entityLiat = new ArrayList<UserRoleEntity>();
for (UserRoleDto dto : dtoList) {
UserRoleEntity entity = mapToUserRoleEntity(dto);
entityLiat.add(entity);
}
return entityLiat;
}
}
UserDto.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserDto {
/**
* ログインID
*/
private String userId;
/**
* ユーザー名
*/
private String userName;
/**
* パスワード
*/
private String password;
/**
* パスワード更新日時
*/
private Timestamp passUpdateDate;
/**
* 性別
*/
private String gender;
/**
* 生年月日
*/
private String birthday;
/**
* 連絡先
*/
private String contact;
/**
* メールアドレス
*/
private String mailAddress;
/**
* ログイン失敗回数
*/
private int loginMissTimes;
/**
* ロック状態
*/
private boolean unlock;
/**
* ユーザー有効無効
*/
private boolean enabled;
/**
* ユーザー有効期限
*/
private Timestamp userDueDate;
/**
* 登録日時
*/
private Timestamp insertDate;
/**
* 更新日時
*/
private Timestamp updateDate;
/**
* 権限Map
*/
// private Map<Integer, String> mapAuthority;
private List<UserRoleDto> userRoleList;
/**
*
* @return
* インスタンス生成処理
*/
public static UserDto getInstance() {
return new UserDto();
}
}
UserRole.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserRoleDto {
//private int id;
/**
* ユーザーIｄ
*/
private String userId;
/**
* 権限Ｉｄ
*/
private String roleId;
/**
* UserRoleDtoのインスタンス生成
* @return
*/
public static UserRoleDto getInstance() {
return new UserRoleDto();
}
}
ServiceConst.java
/**
* 処理失敗
*/
public static final int ERROR = -1;
/**
* 楽観的ロックによる失敗
*/
public static final int OPTIMISTIC_ROCK_ERROR = -2;
/**
* 処理成功
*/
public static final int OK = 0;
/**
* データあり
*/
public static final int THERE_IS_DATA = 1;
/**
* データなし
*/
public static final int NO_DATA = 2;
}
UserManagerDto.java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserManagerDto {
/**
* 楽観的ロック
*/
private String optimisticRockValue;
/**
* ユーザー情報
*/
private UserDto userDto;
/**
* ユーザー情報リスト
*/
private List<UserDto> userDtoList;
/**
* 権限情報リスト
*/
private List<RoleDto> roleDtoList;
// /**
// *ユーザー権限情報リスト
// */
private List<UserRoleDto> userRoleDtoList;
/**
* 処理結果コード
*/
private int result;
/**
* インスタンス取得
* @return
*/
public static UserManagerDto getInstance() {
return new UserManagerDto();
}
}
UserManagerHelper
@Component
public class UserManagerHelper {
/**
* ユーザーDtoヘルパー
*/
@Autowired
UserDtoHelper userDtoHelper;
/**
* ユーザー権限Dtoヘルパー
*/
@Autowired
RoleDtoHelper roleDtoHelper;
@Autowired
UserRoleDtoHelper userRoleDtoHelper;
/**
* UserManagerDto生成処理
*
* @param entity
* @param entityList
* @return
*/
public UserManagerDto createUserServiceDto(UserEntity userEntity, List<UserRoleEntity> userRoleList,
List<RoleEntity> roleEntityList) {
UserManagerDto dto = UserManagerDto.getInstance();
dto.setUserDto(userDtoHelper.mapToUserDto(userEntity));
dto.setUserRoleDtoList(userRoleDtoHelper.mapToUserRoleDtoList(userRoleList));
dto.setRoleDtoList(roleDtoHelper.mapToRoleDtoList(roleEntityList));
return dto;
}
/**
* UserEntity生成処理
*
* @param dto
* @return
*/
public UserEntity getUserEntity(UserManagerDto dto) {
UserEntity entity = userDtoHelper.mapToUserEntity(dto.getUserDto());
return entity;
}
/**
* UserManagerDtoAdd生成処理
*
* @param userEntity
* @return
*/
public UserManagerDto createUserServiceDtoAdd(int result) {
UserManagerDto dto = UserManagerDto.getInstance();
// 処理結果に伴い
switch (result) {
case 1:
dto.setResult(ServiceConst.THERE_IS_DATA);
break;
case 0:
dto.setResult(ServiceConst.NO_DATA);
break;
default:
dto.setResult(ServiceConst.ERROR);
break;
}
return dto;
}
/**
* UserManagerDto生成処理
*
* @param userEntity
* @return
*/
public UserManagerDto createUserManagerServiceDto(UserEntity userEntity) {
// UserManagerDtoインスタンス取得
UserManagerDto managerDto = UserManagerDto.getInstance();
UserDto dto = UserDto.getInstance();
// UserDto取得処理
if (userEntity != null) {
dto = userDtoHelper.mapToUserDto(userEntity);
} else {
dto = null;
}
// UserDto情報セット処理
managerDto.setUserDto(dto);
if (dto == null) {
managerDto.setResult(ServiceConst.NO_DATA);
}
return managerDto;
}
public UserManagerDto createUserManagerDto(List<UserEntity> userEntityList,
List<UserRoleEntity> userRoleEntityList) {
UserManagerDto dto = UserManagerDto.getInstance();
dto.setUserDtoList(userDtoHelper.mapToUserDtoList(userEntityList));
dto.setUserRoleDtoList(userRoleDtoHelper.mapToUserRoleDtoList(userRoleEntityList));
return dto;
// List<UserDto> userDtoList = new ArrayList<UserDto>();
//
// for (UserEntity userEntity : userEntityList) {
// UserDto userDto = userDtoHelper.mapToUserDto(userEntity);
// List<UserRoleDto> userRoleDtolist = new ArrayList<UserRoleDto>();
//
// for (UserRoleEntity userRoleEntity : userRoleEntityList) {
// if (userRoleEntity.getUserId().equals(userEntity.getUserId())) {
// UserRoleDto userRoleDto = new UserRoleDto();
// // userRoleDto.setId(userRoleEntity.getId());
// userRoleDto.setUserId(userRoleEntity.getUserId());
// userRoleDto.setRoleId(userRoleEntity.getRoleId());
// userRoleDtolist.add(userRoleDto);
//
// }
//
// }
//
// if (userRoleDtolist.size() == 0) {
// userRoleDtolist = null;
// }
// userDto.setUserRoleList(userRoleDtolist);
//
// userDtoList.add(userDto);
// }
// dto.setUserDtoList(userDtoList);
//
// return dto;
// }
}
}
UserManagerService.java
public interface UserManagerService {
/**
* ユーザー情報全件取得処理
*
* @return
*/
public UserManagerDto getUserList();
/**
* 施設情報全件取得処理
*
* @return
*/
public UserManagerDto getRoleList();
/**
* ユーザーIDによる、ユーザー1件検索処理
*
* @param userId
* @return
*/
public UserManagerDto getUser(String userId);
/**
* ユーザーIDによる、ユーザー検索処理
*
* @param userId
* @return
*/
public UserManagerDto getUserListByUserId(String userId);
/**
* ユーザー登録処理
*
* @param entity
* @return
*/
public UserManagerDto add(UserManagerDto umsDto);
/**
* ユーザー更新処理
*
* @param entity
* @return
*/
public UserManagerDto update(UserManagerDto umsDto);
/**
* ユーザー削除処理
*
* @param entity
* @return
*/
public UserManagerDto delete(UserManagerDto umsDto);
// テスト用メソッド
public void setUserRepository(UserRepository userRepository);
public void setUserRoleRepository(UserRoleRepository userRoleRepository);
public void setRoleRepository(RoleRepository roleRepository);
public void setPasswordEncoder(PasswordEncoder passwordEncoder);
}
UserManagerServiceImpl.java
@Service
@Transactional
public class UserManagerServiceImpl implements UserManagerService {
@Autowired
UserRepository userRepository;
@Autowired
RoleRepository roleRepository;
@Autowired
UserRoleRepository userRoleRepository;
@Autowired
UserManagerHelper userManagerHelper;
@Autowired
UserRoleDtoHelper userRoleHelper;
@Autowired
RoleDtoHelper roleHelper;
@Autowired
UserDtoHelper userDtoHelper;
@Autowired
PasswordEncoder passwordEncoder;
@Override
public UserManagerDto getUserList() {
List<UserEntity> userEntityList = userRepository.findAll();
List<UserRoleEntity> userRoleList = userRoleRepository.findAll();
UserManagerDto dto = userManagerHelper.createUserManagerDto(userEntityList, userRoleList);
dto.setUserRoleDtoList(userRoleHelper.mapToUserRoleDtoList(userRoleList));
return dto;
}
@Override
public UserManagerDto getRoleList() {
UserManagerDto dto = UserManagerDto.getInstance();
List<RoleEntity> roleEntityList = roleRepository.findAll();
dto.setRoleDtoList(roleHelper.mapToRoleDtoList(roleEntityList));
return dto;
}
@Override
public UserManagerDto getUser(String userId) {
UserManagerDto dto = UserManagerDto.getInstance();
UserEntity userEntity = userRepository.findByUserId(userId);
List<UserRoleEntity> userRoleList = userRoleRepository.findByUserId(userId);
List<RoleEntity> roleEntityList = roleRepository.findAll();
dto = userManagerHelper.createUserServiceDto(userEntity, userRoleList, roleEntityList);
// ユーザー情報楽観ロック情報設定
dto.setOptimisticRockValue(userEntity.toString());
return dto;
}
@Override
public UserManagerDto getUserListByUserId(String userId) {
// 施設情報主キー検索
List<UserEntity> resultUserEntityList = userRepository.getUserIdByUserId(userId);
// 処理結果オブジェクト生成
UserManagerDto userServiceDto = UserManagerDto.getInstance();
List<UserDto> resultUserDtoList = userDtoHelper.mapToUserDtoList(resultUserEntityList);
// 検索結果設定
userServiceDto.setUserDtoList(resultUserDtoList);
// 処理結果設定
if (resultUserEntityList.size() == 0) {
userServiceDto.setResult(ServiceConst.NO_DATA);
} else {
userServiceDto.setResult(ServiceConst.THERE_IS_DATA);
}
return userServiceDto;
}
@Override
@Transactional(readOnly = false, isolation = Isolation.REPEATABLE_READ)
public UserManagerDto add(UserManagerDto umsDto) {
// 施設情報Entityの取得
UserEntity entity = userManagerHelper.getUserEntity(umsDto);
List<UserRoleEntity> usRoleEntList = userRoleHelper.mapToUserRoleEntityList(umsDto.getUserRoleDtoList());
entity.setPassword(passwordEncoder.encode(entity.getPassword()));
int result = userRepository.insert(entity);
boolean resultRole = false;
for (UserRoleEntity usRoleEnt : usRoleEntList) {
resultRole = userRoleRepository.insert(usRoleEnt);
}
if (resultRole == false) {
result = 0;
}
UserManagerDto userServiceDto = userManagerHelper.createUserServiceDtoAdd(result);
return userServiceDto;
}
@Override
public UserManagerDto update(UserManagerDto umsDto) {
UserManagerDto userDto = UserManagerDto.getInstance();
UserEntity updateUserEntity = userManagerHelper.getUserEntity(umsDto);
UserEntity userEntity = userRepository.findByUserId(umsDto.getUserDto().getUserId());
List<UserRoleEntity> updateUsRoleEnt = userRoleHelper.mapToUserRoleEntityList(umsDto.getUserRoleDtoList());
List<UserRoleEntity> dbRoleEnt = userRoleRepository.findByUserId(umsDto.getUserDto().getUserId());
boolean resultRole = false;
if (updateUsRoleEnt.size() == dbRoleEnt.size()) {
resultRole = true;
}
if (updateUsRoleEnt.size() > dbRoleEnt.size()) {
for (UserRoleEntity usRoleEnt : updateUsRoleEnt) {
resultRole = userRoleRepository.insert(usRoleEnt);
}
}
if (updateUsRoleEnt.size() < dbRoleEnt.size()) {
for (UserRoleEntity usRoleEnt : updateUsRoleEnt) {
resultRole = userRoleRepository.updateDelete(usRoleEnt);
}
}
if (resultRole == false) {
userDto.setResult(ServiceConst.ERROR);
return userDto;
}
System.out.println(userEntity.toString());
System.out.println(umsDto.getOptimisticRockValue());
// 楽観的ロックによるチェック
if (userEntity.toString().equals(umsDto.getOptimisticRockValue())) {
// ストレージから取得したエンコードされたパスワードが、エンコードされた後に送信された生のパスワードと一致することを確認します。
if (!passwordEncoder.matches(updateUserEntity.getPassword(), userEntity.getPassword())) {
Timestamp timestamp = new Timestamp(System.currentTimeMillis());
updateUserEntity.setPassUpdateDate(timestamp);
}
updateUserEntity.setPassword(passwordEncoder.encode(updateUserEntity.getPassword()));
// 施設情報更新
int result = userRepository.update(updateUserEntity);
if (result != 1) {
userDto.setResult(ServiceConst.ERROR);
} else {
userDto.setResult(ServiceConst.OK);
}
} else {
userDto.setResult(ServiceConst.OPTIMISTIC_ROCK_ERROR);
}
return userDto;
}
@Override
public UserManagerDto delete(UserManagerDto umsDto) {
UserManagerDto dto = UserManagerDto.getInstance();
int result = userRepository.delete(umsDto.getUserDto().getUserId());
int resultRole = userRoleRepository.delete(umsDto.getUserDto().getUserId());
if (result != 0 && resultRole != 0) {
dto.setResult(ServiceConst.OK);
return dto;
}
dto.setResult(ServiceConst.ERROR);
return dto;
}
@Override
public void setUserRepository(UserRepository userRepository) {
this.userRepository = userRepository;
}
@Override
public void setUserRoleRepository(UserRoleRepository userRoleRepository) {
this.userRoleRepository = userRoleRepository;
}
@Override
public void setRoleRepository(RoleRepository roleRepository) {
this.roleRepository = roleRepository;
}
@Override
public void setPasswordEncoder(PasswordEncoder passwordEncoder) {
this.passwordEncoder = passwordEncoder;
}
}
LoginController.java
@Controller
public class LoginController {
@GetMapping("/login")
public String getLogin() {
return "authority/login";
}
}
Service~controller
MenuController.java
@Controller
public class MenuController {
@GetMapping("/menu")
public String createMenu() {
return "menu/menu";
}
}
UserListController
UserListController.java
@Controller
public class UserListController {
/**
* ユーザー一覧ヘルパー
*/
@Autowired
UserManagerHelper userManagerHelper;
@Autowired
UserListHelper userListHelper;
@Autowired
UserManagerService userManagerService;
/**
* ユーザーサービス
*
*/
@GetMapping("/user/list")
public String createUserList(Model model) {
UserManagerDto userManagerDto = userManagerService.getUserList();
UserListForm userListForm = userListHelper.createUserListForm(userManagerDto);
model.addAttribute("userListForm", userListForm.getUserFormList());
model.addAttribute("roleList", userListForm.getUserRoleFormList());
return "user/user-list";
}
}
UserListHelper.java
@Component
public class UserListHelper {
@Autowired
UserFormHelper userFormHelper;
@Autowired
UserRoleFormHelper userRoleFormHelper;
public UserListForm createUserListForm(UserManagerDto dto) {
UserListForm form = new UserListForm();
List<UserDto> entityList = dto.getUserDtoList();
List<UserRoleDto> useroRoleList = dto.getUserRoleDtoList();
List<UserForm> formList = userFormHelper.createUserFormList(entityList);
List<UserRoleForm> UserRoleForm = userRoleFormHelper.createUserRoleFormList(useroRoleList);
form.setUserFormList(formList);
form.setUserRoleFormList(UserRoleForm);
//処理結果を元にメッセージの設定
if (dto.getResult() == ServiceConst.NO_DATA) {
form.setSysMsg("0件です。");
}
return form;
}
}
UserListForm.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserListForm {
/**
* システムメッセージ
*/
private String sysMsg;
/**
* ユーザー情報リスト
*/
private List<UserForm> userFormList;
/**
* 種別情報リスト
*/
private List<UserRoleForm> userRoleFormList;
}
UserAddController
UserAddController.java
@Controller
public class UserAddController {
/**
* ユーザー情報登録ヘルパー
*/
@Autowired
UserAddHelper userAddHelper;
/**
* 権限情報登録ヘルパー
*/
@Autowired
RoleFormHelper roleHelper;
/**
* ユーザー情報サービス
*/
@Autowired
UserManagerService userManagerService;
/**
* 施設情報セッション
*/
@Autowired
UserSession userSession;
@GetMapping("/user/add")
public String createUserAdd(ModelMap mdMap) {
// ユーザー情報登録フォーム
UserAddForm form = null;
// リダイレクト時の処理
if (mdMap.containsKey("errors")) {
// sessionオブジェクトからFormオブジェクトの生成
form = userAddHelper.createUserAddForm(userSession);
// ModelMapオブジェクトにFormオブジェクトをセット
mdMap.addAttribute("userAddForm", form);
// keyの生成
String key = BindingResult.MODEL_KEY_PREFIX + "userAddForm";
// バリデータチェック結果を設定
mdMap.addAttribute(key, mdMap.get("errors"));
} else {
// ユーザー情報セッションをクリア
userSession.clear();
UserManagerDto dto = userManagerService.getRoleList();
form = userAddHelper.createUserAddForm(dto);
userSession.setRoleFormList(form.getRoleFormList());
mdMap.addAttribute("userAddForm", form);
}
return "user/user-add";
}
}
UserAddHelper.java
@Component
public class UserAddHelper {
/**
* ユーザー情報ヘルパー
*/
@Autowired
UserFormHelper userFormHelper;
/**
* UserManagerDtoからUserAddForm生成処理
*
* @param dto
* @return
*/
public UserAddForm createUserAddForm(final UserManagerDto dto) {
UserAddForm form = UserAddForm.getInstance();
List<RoleDto> list = dto.getRoleDtoList();
List<RoleForm> convertList = new ArrayList<RoleForm>();
for (RoleDto data : list) {
convertList.add(new RoleForm(data.getRoleId(), data.getRoleName()));
}
form.setRoleFormList(convertList);
return form;
}
/**
* セッションオブジェクトからUserAddForm生成処理
*
* @param session 施設情報セッション
* @return
*/
public UserAddForm createUserAddForm(final UserSession session) {
UserAddForm form = UserAddForm.getInstance();
form.setUserForm(session.getUserForm());
form.setUserRoleFormList(session.getUserRoleFormList());
form.setRoleFormList(session.getRoleFormList());
return form;
}
}
UserAddForm.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserAddForm {
/**
* システムメッセージ
*/
private String sysMsg;
/**
* ユーザー情報
*/
@Valid
private UserForm userForm;
/**
* ユーザー権限情報
*/
private List<UserRoleForm> userRoleFormList;
/**
* ユーザー権限情報
*/
private List<RoleForm> roleFormList;
/**
*
* @return
*/
public UserForm getUserForm() {
if (userForm == null) {
userForm = UserForm.getInstance();
}
return userForm;
}
public List<UserRoleForm> getUserRoleFormList() {
if (userRoleFormList == null) {
userRoleFormList = new ArrayList<UserRoleForm>();
}
return userRoleFormList;
}
/**
* UserAddFormインスタンス生成処理
*
* @return
*/
public static UserAddForm getInstance() {
return new UserAddForm();
}
}
UserDetailController
UserDetailController.java
@Controller
public class UserDetailController {
/**
* ユーザー情報登録ヘルパー
*/
@Autowired
UserDetailHelper userDetailHelper;
/**
* ユーザー情報サービス
*/
@Autowired
UserManagerService userManagerService;
@Autowired
RoleFormHelper roleHelper;
/**
* ユーザー情報セッション
*/
@Autowired
UserSession userSession;
/**
* ユーザー情報登録リクエスト処理
*
* @param mdMap
* @return
*/
@GetMapping("/user/detail/{userId}")
public String getUserDetail(@PathVariable String userId, ModelMap mdMap) {
// ユーザー情報登録フォーム
UserDetailForm form = null;
// リダイレクト時の処理
if (mdMap.containsKey("errors")) {
// sessionオブジェクトから入力内容の取得
form = userDetailHelper.getUserDetailForm(userSession);
// モデルマップオブジェクトにformオブジェクトをセット
mdMap.addAttribute("userDetailForm", form);
// keyの生成
String key = BindingResult.MODEL_KEY_PREFIX + "userDetailForm";
mdMap.addAttribute(key, mdMap.get("errors"));
} else {
// ユーザー情報セッションをクリア
userSession.clear();
// ユーザー情報取得処理
UserManagerDto userManagerDto = userManagerService.getUser(userId);
// ユーザー情報登録フォーム生成
form = userDetailHelper.createUserDetailForm(userManagerDto);
// ユーザー情報セッションへユーザー情報、ユーザー権限リスト情報、ロック情報をセット
userSession.setUserForm(form.getUserForm());
userSession.setUserRoleFormList(form.getUserRoleFormList());
userSession.setBeforeUserForm(form.getUserForm());
userSession.setOptimisticRockValue(userManagerDto.getOptimisticRockValue());
// モデルマップオブジェクトにformオブジェクトをセット
mdMap.addAttribute("userDetailForm", form);
}
return "user/user-detail";
}
}
UserDetailHelper.java
@Component
public class UserDetailHelper {
@Autowired
UserFormHelper userFormHelper;
@Autowired
UserRoleFormHelper userRoleFormHelper;
@Autowired
RoleFormHelper roleFormHelper;
/**
* UserSessionデータからUserDetailFormオブジェクト取得処理
* @param userSession
* @return
*/
public UserDetailForm getUserDetailForm(UserSession userSession) {
UserDetailForm form = UserDetailForm.getInstance();
form.setUserForm(userSession.getUserForm());
form.setUserRoleFormList(userSession.getUserRoleFormList());
form.setRoleFormList(userSession.getRoleFormList());
return form;
}
/**
* UserDetailFormオブジェクト生成 処理
* @param userManagerDto
* @param userRoleManagerDto
* @return
*/
public UserDetailForm createUserDetailForm(UserManagerDto userManagerDto) {
//ユーザーDtoの取得
UserDto userDto = userManagerDto.getUserDto();
//ユーザー権限Dtoリストの取得
List<UserRoleDto> userRoleDtoList = userManagerDto.getUserRoleDtoList();
//権限情報リストの取得
List<RoleDto> roleDtoList = userManagerDto.getRoleDtoList();
//UserDetailFormのインスタンス取得
UserDetailForm form = UserDetailForm.getInstance();
//DtoからFormへのデータ変換作業
UserForm userForm = userFormHelper.createUserForm(userDto);
List<UserRoleForm> userRoleFormList = userRoleFormHelper.createUserRoleFormList(userRoleDtoList);
List<RoleForm> roleFormList = roleFormHelper.createRoleFormList(roleDtoList);
form.setUserForm(userForm);
form.setUserRoleFormList(userRoleFormList);
form.setRoleFormList(roleFormList);
return form;
}
}
UserDetailForm.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserDetailForm {
/**
* システムメッセージ
*/
private String sysMsg;
/**
* ユーザー情報
*/
@Valid
private UserForm userForm;
/**
* ユーザー権限情報
*/
private List<UserRoleForm> userRoleFormList;
/**
* 権限情報リスト
*/
private List<RoleForm> roleFormList;
/**
*
* @return
*/
public UserForm getUserForm() {
if (userForm == null) {
userForm = UserForm.getInstance();
}
return userForm;
}
public List<UserRoleForm> getUserRoleFormList() {
if (userRoleFormList == null) {
userRoleFormList = new ArrayList<UserRoleForm>();
}
return userRoleFormList;
}
public static UserDetailForm getInstance() {
UserDetailForm userDetailForm = new UserDetailForm();
return userDetailForm;
}
}
UserConfirmController
UserConfirmController.java
@Controller
@Data
public class UserConfirmController {
/**
* メッセージプロパティ
*/
@Autowired
MessageSource msg;
/**
* ユーザー情報セッション
*/
@Autowired
UserSession userSession;
/**
* ユーザー情報確認ヘルパー
*/
@Autowired
UserConfirmHelper userConfirmHelper;
/**
* ユーザー情報管理サービス
*/
@Autowired
UserManagerService userService;
/**
* 新規登録操作からの確認リクエスト処理
*
* @param inputForm
* @param result
* @param ra
* @param model
* @return
*/
@PostMapping(path = "/user/confirm", params = "add")
public String postUserConfirmAdd(@ModelAttribute @Validated UserAddForm inputForm, BindingResult result,
RedirectAttributes ra, Model model) {
// エラー判定フラグ
boolean errFlag = false;
// ユーザー情報をセッションにセット
userSession.setUserForm(inputForm.getUserForm());
userSession.setRoleFormList(inputForm.getRoleFormList());
userSession.setUserRoleFormList(userConfirmHelper.convertRoleList(inputForm.getRoleFormList()));
// バリデータエラー判定
if (result.hasErrors()) {
errFlag = true;
}
// FormからDtoデータの取得
UserManagerDto dto = userConfirmHelper.createUserManagerServiceDto(inputForm);
// userIdの重複チェック
UserManagerDto resultDto = userService.getUserListByUserId(dto.getUserDto().getUserId());
// ユーザー名称が重複していた場合
if (resultDto.getUserDtoList().size() != 0) {
// エラーメッセージの設定
// msg
result.rejectValue("userForm.userId", null, msg.getMessage("User.duplicate", null, Locale.getDefault()));
errFlag = true;
}
if (!(inputForm.getUserForm().getPassword().equals(inputForm.getUserForm().getRetypePassword()))) {
// エラーメッセージの設定
// msg
result.rejectValue("userForm.password", null,
msg.getMessage("User.match", new String[] { "パスワード" }, Locale.getDefault()));
errFlag = true;
} else if (!(inputForm.getUserForm().getMailAddress().equals(inputForm.getUserForm().getRetypeMailAddress()))) {
// エラーメッセージの設定
// msg
result.rejectValue("userForm.mailAddress", null,
msg.getMessage("User.match", new String[] { "メールアドレス" }, Locale.getDefault()));
errFlag = true;
}
// セッションからFormへの出力情報の取得
UserConfirmForm form = userConfirmHelper.createUserConfirmForm(userSession);
form.setBtnName(msg.getMessage("label.add", null, Locale.getDefault()));
form.setBtnAction(msg.getMessage("action.add", null, Locale.getDefault()));
// リダイレクト処理
if (errFlag == true) {
ra.addFlashAttribute("errors", result);
return "redirect:/user/add";
}
// ビューの設定
model.addAttribute("userConfirmForm", form);
return "user/user-confirm";
}
/**
* 更新操作からの確認リクエスト処理
*
* @param inputForm
* @param result
* @param ra
* @param model
* @return
*/
@PostMapping(path = "/user/confirm", params = "update")
public String postUserConfirmUpdate(@ModelAttribute @Validated UserDetailForm inputForm, BindingResult result,
RedirectAttributes ra, Model model) {
// エラー判定フラグ
boolean errFlag = false;
// バリデータエラー判定
if (result.hasErrors()) {
errFlag = true;
}
// 編集前とどこが修正箇所なのかのチェック
int checkValue = userConfirmHelper.checkUpdated(inputForm, userSession.getBeforeUserForm());
switch (checkValue) {
case UserConfirmHelper.NO_UPDATE:
// 何も更新されていないので、詳細画面にリダイレクト
// msg.getMessage("User.notChange", null, Locale.getDefault())
result.rejectValue("sysMsg", null, msg.getMessage("User.notChange", null, Locale.getDefault()));
errFlag = true;
break;
default:
break;
}
if (!(inputForm.getUserForm().getPassword().equals(inputForm.getUserForm().getRetypePassword()))) {
// エラーメッセージの設定
// msg
result.rejectValue("userForm.password", null,
msg.getMessage("User.match", new String[] { "パスワード" }, Locale.getDefault()));
errFlag = true;
} else if (!(inputForm.getUserForm().getMailAddress().equals(inputForm.getUserForm().getRetypeMailAddress()))) {
// エラーメッセージの設定
// msg
result.rejectValue("userForm.mailAddress", null,
msg.getMessage("User.match", new String[] { "メールアドレス" }, Locale.getDefault()));
errFlag = true;
}
userSession.setUserRoleFormList(userConfirmHelper.convertRoleList(inputForm.getRoleFormList()));
userSession.setRoleFormList(inputForm.getRoleFormList());
userSession.setUserForm(inputForm.getUserForm());
// セッションからFormへの出力情報の取得
UserConfirmForm form = userConfirmHelper.createUserConfirmForm(userSession);
form.setBtnName(msg.getMessage("label.update", null, Locale.getDefault()));
form.setBtnAction(msg.getMessage("action.update", null, Locale.getDefault()));
// リダイレクト処理
if (errFlag == true) {
ra.addFlashAttribute("errors", result);
return "redirect:/user/detail/" + userSession.getUserForm().getUserId();
}
// ビューの設定
model.addAttribute("userConfirmForm", form);
return "user/user-confirm";
}
/**
* 削除操作からの確認リクエスト処理
*
* @param inputForm
* @param result
* @param ra
* @param model
* @return
*/
@PostMapping(path = "/user/confirm", params = "delete")
public String postUserConfirmDelete(@ModelAttribute UserDetailForm inputForm, BindingResult result,
RedirectAttributes ra, Model model) {
// 現在のデータを取得
UserManagerDto fmDto = userService.getUser(userSession.getBeforeUserForm().getUserId());
// 楽観ロックだとユーザーIdが変わっていたら比べることができないので悲観ロック？？
// データが更新されていないかのチェック
int checkValue = userConfirmHelper.checkUpdated(fmDto, userSession.getBeforeUserForm());
// エラー判定フラグ
boolean errFlag = false;
if (checkValue != UserConfirmHelper.NO_UPDATE) {
result.rejectValue("sysMsg", null, "データが更新されている可能性があります");
errFlag = true;
}
// Formへ出力情報の取得
UserConfirmForm form = userConfirmHelper.createUserConfirmForm(fmDto);
form.setBtnName(msg.getMessage("label.delete", null, Locale.getDefault()));
form.setBtnAction(msg.getMessage("action.delete", null, Locale.getDefault()));
// DBのデータをセッションに設定
userSession.setUserForm(form.getUserForm());
userSession.setUserRoleFormList(form.getUserRoleFormList());
userSession.setRoleFormList(form.getRoleFormList());
// リダイレクト処理
if (errFlag == true) {
ra.addFlashAttribute("errors", result);
return "redirect:/user/detail/" + userSession.getUserForm().getUserId();
}
// ビューの設定
model.addAttribute("userConfirmForm", form);
return "user/user-confirm";
}
}
UserConfirmHelper.java
@Component
public class UserConfirmHelper {
//処理結果コード
public static final int NO_UPDATE = 0;
public static final int USERID_UPDATED = 1;
public static final int USERNAME_UPDATED = 10;
public static final int PASSWAOR_UPDATED = 100;
public static final int GENDER_UPDATED = 1000;
public static final int BIRTYDAY_UPDATED = 10000;
public static final int CONTACT_UPDATED = 100000;
public static final int MAILADDRESS_UPDATED = 1000000;
@Autowired
UserFormHelper userFormHelper;
@Autowired
UserRoleFormHelper userRoleFormHelper;
@Autowired
RoleFormHelper roleFormHelper;
/**
* 確認画面Form生成処理
* @param userSession
* @return
*/
public UserConfirmForm createUserConfirmForm(UserSession userSession) {
UserConfirmForm form = UserConfirmForm.getInstance();
form.setUserForm(userSession.getUserForm());
form.setUserRoleFormList(userSession.getUserRoleFormList());
form.setRoleFormList(userSession.getRoleFormList());
return form;
}
/**
* 確認画面Form生成処理
* @param facilitySession
* @return
*/
public UserConfirmForm createUserConfirmForm(UserManagerDto userManagerDto) {
UserDto userDto = userManagerDto.getUserDto();
//ユーザー権限Dtoリストの取得
List<UserRoleDto> userRoleDtoList = userManagerDto.getUserRoleDtoList();
//権限情報リストの取得
List<RoleDto> roleDtoList = userManagerDto.getRoleDtoList();
UserConfirmForm form = UserConfirmForm.getInstance();
if (userDto != null) {
UserForm userForm = userFormHelper.createUserForm(userDto);
List<UserRoleForm> userRoleFormList = userRoleFormHelper.createUserRoleFormList(userRoleDtoList);
List<RoleForm> roleFormList = roleFormHelper.createRoleFormList(roleDtoList);
form.setUserForm(userForm);
form.setUserRoleFormList(userRoleFormList);
form.setRoleFormList(roleFormList);
}
return form;
}
/**
* ユーザー情報管理Dto生成処理
* @param inputForm
* @return
*/
public UserManagerDto createUserManagerServiceDto(UserAddForm inputForm) {
UserForm userForm = inputForm.getUserForm();
UserManagerDto userServiceDto = UserManagerDto.getInstance();
UserDto userDto = userFormHelper.createUserDto(userForm);
userServiceDto.setUserDto(userDto);
return userServiceDto;
}
/**
* ユーザー情報管理Dto生成処理
* @param inputForm
* @return
*/
public UserManagerDto getUserManagerServiceDto(UserDetailForm inputForm) {
UserForm userForm = inputForm.getUserForm();
UserManagerDto userServiceDto = UserManagerDto.getInstance();
UserDto userDto = userFormHelper.createUserDto(userForm);
userServiceDto.setUserDto(userDto);
return userServiceDto;
}
public UserRoleForm convertRole(RoleForm roleForm) {
UserRoleForm userRoleForm = new UserRoleForm();
userRoleForm.setRoleId(roleForm.getRoleId());
return userRoleForm;
}
public List<UserRoleForm> convertRoleList(List<RoleForm> roleList) {
List<UserRoleForm> userRoleList = new ArrayList<UserRoleForm>();
for (RoleForm roleForm : roleList) {
if (roleForm.getRoleId() != null) {
userRoleList.add(convertRole(roleForm));
}
}
return userRoleList;
}
/**
* ユーザー情報が更新されているかのチェック
* @param inputForm
* @param beforeUserForm
* @return
*/
public int checkUpdated(UserDetailForm inputForm, UserForm beforeUserForm) {
return this.checkUpdated(inputForm.getUserForm(), beforeUserForm);
}
/**
* ユーザー情報が更新されているかのチェック
* @param userManagerDto
* @param beforeUserForm
* @return
*/
public int checkUpdated(UserManagerDto userManagerDto, UserForm beforeUserForm) {
UserDto userDto = userManagerDto.getUserDto();
UserForm userForm = userFormHelper.createUserForm(userDto);
return this.checkUpdated(userForm, beforeUserForm);
}
/**
* ユーザー情報が更新されているかのチェック
* @param userForm
* @param beforeUserForm
* @return
*/
private int checkUpdated(UserForm userForm, UserForm beforeUserForm) {
String userId = userForm.getUserId();
String userName = userForm.getUserName();
String password = userForm.getPassword();
String gender = userForm.getGender();
String birthday = userForm.getBirthday();
String contact = userForm.getContact();
String mailAddress = userForm.getMailAddress();
String beforeUserId = beforeUserForm.getUserId();
String beforeUserName = beforeUserForm.getUserName();
String beforePassword = beforeUserForm.getPassword();
String beforeGender = beforeUserForm.getGender();
String beforeBirthday = beforeUserForm.getBirthday();
String beforeContact = beforeUserForm.getContact();
String beforeMailAddress = beforeUserForm.getMailAddress();
int result = NO_UPDATE;
if (userId.equals(beforeUserId) == false) {
result += USERID_UPDATED;
} else if (userName != null && userName.equals(beforeUserName) == false) {
result += USERNAME_UPDATED;
} else if (password != null && password.equals(beforePassword) == false) {
result += PASSWAOR_UPDATED;
} else if (gender != null && gender.equals(beforeGender) == false) {
result += GENDER_UPDATED;
} else if (birthday != null && birthday.equals(beforeBirthday) == false) {
result += BIRTYDAY_UPDATED;
} else if (contact != null && contact.equals(beforeContact) == false) {
result += CONTACT_UPDATED;
} else if (mailAddress != null && mailAddress.equals(beforeMailAddress) == false) {
result += MAILADDRESS_UPDATED;
}
return result;
}
UserConfirmForm.java
@Data
@NoArgsConstructor
@AllArgsConstructor
public class UserConfirmForm {
/**
* システムメッセージ
*/
private String sysMsg;
/**
* 施設情報
*/
private UserForm userForm;
/**
* ユーザー権限情報
*/
private List<UserRoleForm> userRoleFormList;
/**
* 施設種別情報
*/
private List<RoleForm> roleFormList;
private String btnName;
private String btnAction;
public static UserConfirmForm getInstance() {
return new UserConfirmForm();
}
}
UserCompleteController
UserCompleteController.java
@Controller
public class UserCompleteController {
/**
* メッセージプロパティ
*/
@Autowired
MessageSource msg;
/**
* ユーザー情報セッションオブジェクト
*/
@Autowired
UserSession userSession;
/**
* ユーザー情報管理サービス
*/
@Autowired
UserManagerService userManagerService;
/**
* ユーザー情報完了ヘルパー
*/
@Autowired
UserCompleteHelper userCompleteHelper;
@Autowired
UserRoleFormHelper userRoleFormHelper;
/**
* ユーザー情報操作完了リクエスト処理
*
* @param modelMap
* @return
*/
@GetMapping(path = "/user/complete")
public String createUserConmplete(ModelMap modelMap) {
UserCompleteForm form = UserCompleteForm.getInstance();
if (modelMap.get("data") == null) {
return "/error/error";
}
if (modelMap.containsKey("data")) {
// ビューの設定
modelMap.addAttribute("userComplete", modelMap.get("data"));
} else {
form.setSysMsg(msg.getMessage("Already.completed", null, Locale.getDefault()));
modelMap.addAttribute("userComplete", form);
}
return "user/user-complete";
}
/**
* ユーザー情報登録完了リクエスト処理
*
* @param ra
* @param model
* @return
*/
@PostMapping(path = "/user/complete", params = "add")
public String createUserCompleteAdd(RedirectAttributes ra, Model model,
@AuthenticationPrincipal UserDetailsImpl userDetailsImpl) {
UserCompleteForm form = UserCompleteForm.getInstance();
if (userSession.getUserForm().getUserId() == null) {
form.setSysMsg("セッションが破棄されております。もう一度作業をし直してください");
ra.addFlashAttribute("data", form);
return "redirect:/user/complete";
}
UserManagerDto dto = userCompleteHelper.convertUserManagerDto(userSession);
dto.setUserRoleDtoList(
userRoleFormHelper.createUserRoleDtoList(userSession.getUserRoleFormList(), userSession.getUserForm()));
UserManagerDto resultDto = userManagerService.add(dto);
form = userCompleteHelper.creatUserCompleteForm(resultDto);
form.setSysMsg("登録が完了しました");
form.setBtnName(msg.getMessage("label.add", null, Locale.getDefault()));
ra.addFlashAttribute("data", form);
// セッションクリア
userSession.clear();
System.out.println("comlete-User-Clear" + userSession.getUserForm());
return "redirect:/user/complete";
}
/**
* ユーザー情報更新完了リクエスト処理
*
* @param ra
* @param model
* @return
*/
@PostMapping(path = "/user/complete", params = "update")
public String createUserCompleteUpdate(RedirectAttributes ra, Model model) {
UserCompleteForm form = new UserCompleteForm();
// セッションから情報を取得
UserManagerDto userDto = userCompleteHelper.convertUserManagerDto(userSession);
userDto.setUserRoleDtoList(
userRoleFormHelper.createUserRoleDtoList(userSession.getUserRoleFormList(), userSession.getUserForm()));
System.out.println("ユーザー名称：" + userDto.getUserDto().getUserName());
// ユーザー情報更新処理
UserManagerDto r_userDto = userManagerService.update(userDto);
switch (r_userDto.getResult()) {
case ServiceConst.OK:
form.setBtnName(msg.getMessage("label.update", null, Locale.getDefault()));
break;
case ServiceConst.OPTIMISTIC_ROCK_ERROR:
form.setSysMsg(msg.getMessage("User.optimistic", null, Locale.getDefault()));
break;
default:
return "redirect:/error/error";
}
System.out.println("");
ra.addFlashAttribute("data", form);
userSession.clear();
return "redirect:/user/complete";
}
/**
* ユーザー情報削除完了リクエスト処理
*
* @param ra
* @param model
* @return
*/
@PostMapping(path = "/user/complete", params = "delete")
public String createUserCompleteDelete(RedirectAttributes ra, Model model) {
UserCompleteForm form = new UserCompleteForm();
// セッションから情報を取得
UserManagerDto userDto = userCompleteHelper.convertUserManagerDto(userSession);
UserManagerDto result = userManagerService.delete(userDto);
if (result.getResult() == ServiceConst.ERROR) {
return "redirect:/error/error";
}
form.setBtnName(msg.getMessage("label.delete", null, Locale.getDefault()));
ra.addFlashAttribute("data", form);
userSession.clear();
return "redirect:/user/complete";
}
}
UserCompleteHelper.java
@Component
public class UserCompleteHelper {
@Autowired
UserFormHelper userFormHelper;
public UserManagerDto convertUserManagerDto(UserSession session) {
UserManagerDto dto = UserManagerDto.getInstance();
if (session.getUserForm() != null) {
UserForm userForm = session.getUserForm();
UserDto userDto = userFormHelper.createUserDto(userForm);
dto.setUserDto(userDto);
}
if (session.getOptimisticRockValue() != null) {
dto.setOptimisticRockValue(session.getOptimisticRockValue());
}
//dto.getUserDto().setUpdateUserDto(UserDto.getInstance());
return dto;
}
/**
*
* @param dto
* @return
*/
public UserCompleteForm creatUserCompleteForm(UserManagerDto dto) {
UserCompleteForm form = UserCompleteForm.getInstance();
// 処理結果に伴い
switch (dto.getResult()) {
case 1:
form.setSysMsg(null);
break;
case 2:
form.setSysMsg(null);
break;
default:
break;
}
return form;
}
}
UserCompleteForm.java
@Data
public class UserCompleteForm {
private String sysMsg;
private String link;
private String btnName;
public static UserCompleteForm getInstance() {
return new UserCompleteForm();
}
}