Repository~Service~Controller~html

----
properties
----

```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
```
```properties: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=他のユーザーが、情報を更新した可能性があります。情報を確認したうえ、作業をやり直し願います


```
```properties:text.propaties
# =======================================
# ラベル
# =======================================
label.add=登録
label.update=更新
label.delete=削除


# =======================================
# アクション
# =======================================
action.add=add
action.update=update
action.delete=delete


# =======================================
# ユーザー権限名
# =======================================
authority.admin=管理者
authority.general=一般

```

Repository~Service
------------
```java: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;
//	}

}
```

```java: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);

}
```
```xml: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>
```

```java:UserRoleEntity.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserRoleEntity {

	// t_user_role テーブルのid
	//private int id;

	private String userId;

	private String roleId;

}

```
```java: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じゃない限りは「削除不可」のメッセージを出す　　　ようにすべき？
```
```java: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;

	}

}
```

```xml: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>
```
```java: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;
	}

}

```
```java: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();
	}

}
```

```java: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();
	}

}
```
```java: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;
}
```
```java: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();
	}
}
```
```java: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;
		//	}

	}
}
```
```java: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);

}
```
```java: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;
	}

}
```

```java:LoginController.java
@Controller
public class LoginController {

	@GetMapping("/login")
	public String getLogin() {

		return "authority/login";
	}
}

```
Service~controller
----

```java:MenuController.java
@Controller
public class MenuController {

	@GetMapping("/menu")
	public String createMenu() {
		return "menu/menu";
	}
}
```
UserListController
----
```java: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";

	}
}

```

```java: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;
	}

}

```
```java:UserListForm.java
@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
public class UserListForm {

	/**
	 * システムメッセージ
	 */
	private String sysMsg;

	/**
	 * ユーザー情報リスト
	 */
	private List<UserForm> userFormList;

	/**
	 * 種別情報リスト
	 */
	private List<UserRoleForm> userRoleFormList;
}

```
UserAddController
----
```java: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";
	}

}

```

```java: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;
	}
}

```
```java: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
----
```java: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";

	}
}

```
```java: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;
	}

}
```
```java: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
----
```java: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;
	}


```
```java: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
----
```java: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";
	}
}

```
```java: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;
	}
}
```
```java:UserCompleteForm.java
@Data
public class UserCompleteForm {

	private String sysMsg;

	private String link;

	private String btnName;

	public static UserCompleteForm getInstance() {
		return new UserCompleteForm();
	}

}
```
小休止
----