반응형

 

ataTable.addColumn('number',
'날짜');구글 차트를 이용한 데이터 시각화를 하려고 한다. 

날자 to 날자를 선택하면 

해당 기간에 쓴글을 표로 보여주고 표를 토대로 

구글차트를 이용하여 데이터시각화를 보여주려고 한다. 

 

 

 

우선 가장 기본이 되는 sql문 부터 보자 .

 

   <select id="admin_findDate" resultType="hashmap">
   select board_type,count(board_type)as count from job_board where board_regdate
   BETWEEN TO_DATE(#{date1}, 'MM-DD-YY') and TO_DATE(#{date2}, 'MM-DD-YY') 
   GROUP by board_type
   </select>

sql문을 보면 이제 date1과 date2를 받아주어야한다. 

 

ajax를 봐보자

 

$('#join-date')
				.click(
						function() {
							var date1 = $('#date1').val();
							var date2 = $('#date2').val();

							str = '';
							$
									.ajax({
										type : 'post',
										url : '<c:url value ="/admin/findDate"/>',
										dataType : "json",
										data : {
											date1 : date1,
											date2 : date2
										},
										success : function(data) {
											for ( var i = 1 in data) {
												str += "<tr>"
												str += "<td>"
												if(data[i].BOARD_TYPE == 1){
													str += "사기업게시판(1)"
												}
												else if(data[i].BOARD_TYPE == 2){
													str += "공기업게시판(2)"
												}
												else if(data[i].BOARD_TYPE == 3){
													str += "아시아게시판(3)"
												}
												else if(data[i].BOARD_TYPE == 4){
													str += "유럽게시판(4)"
												}
												else if(data[i].BOARD_TYPE == 5){
													str += "남미게시판(5)"
												}
												else if(data[i].BOARD_TYPE == 6){
													str += "북미게시판(6)"
												}
												else if(data[i].BOARD_TYPE == 7){
													str += "아프리카(7)"
												}
												else if(data[i].BOARD_TYPE == 8){
													str += "국가자격증(8)"
												}
												else if(data[i].BOARD_TYPE == 9){
													str += "민간자격증(9)"
												}
												else if(data[i].BOARD_TYPE == 10){
													str += "어학자격증(10)"
												}
												else if(data[i].BOARD_TYPE == 11){
													str += "자유게시판(11)"
												}
												else if(data[i].BOARD_TYPE == 12){
													str += "취뽀게시판(12)"
												}
												else if(data[i].BOARD_TYPE == 13){
													str += "취업게시판(13)"
												}
												else if(data[i].BOARD_TYPE == 14){
													str += "자격증게시판(14)"
												}
												else if(data[i].BOARD_TYPE == 15){
													str += "자소서게시판(15)"
												}
												else if(data[i].BOARD_TYPE == 16){
													str += "삭제(16)"
												}
												str +=	 "</td>"
												str += "<td>" + data[i].COUNT
														+ "</td>"
												str += "</tr>"
											}
											$("#board_info").html(str);
											$("#chart-tbl").DataTable();

											google.charts.load('current',
													{
														packages : [
																'corechart',
																'bar' ]
													});

											google.charts
													.setOnLoadCallback(drawBasic);

											function drawBasic() {

												console.log(data.length);

												var dataTable = new google.visualization.DataTable();
												dataTable.addColumn('number',
														'날짜');
												dataTable.addColumn('number',
														'글수');

												chart_data = [];

												for ( var i = 1 in data) {
													chart_data.push([
															data[i].BOARD_TYPE,
															data[i].COUNT ])
												}

												console.log(chart_data);

												dataTable.addRows(chart_data);

												var options = {

													title : '게시글 수',
													hAxis : {
														title : '게시판명'
													},
													vAxis : {
														title : '글수'
													}
												};

												var chart = new google.visualization.ColumnChart(

														document
																.getElementById('chart_div'));

												chart.draw(dataTable, options);

											}
										},
										error : function(request, status, error) {
											console.log('에러발생!!');
											console.log("code:"
													+ request.status + "\n"
													+ "message:"
													+ request.responseText
													+ "\n" + "error:" + error);
										}
									}) // end ajax
						})
		//$("#board-admin").DataTable();
	})
</script>

우선 데이터 타입이 숫자형식으로 오기때문에 

if문으로 각 숫자에 준하는 게시판을 대입해준다. 

ex) 11번이면 자유게시판

 

그리고 빈문자열 str에 추가해 주어 데이터 테이블까지 적용해준다. 

html(str) 이렇게

 

 

다음 구글차트를 로드해준다. 

 

ataTable.addColumn('number','날짜');

이런식으로 데이터 컬럼을 추가해준다. 

이것은 구글차트에 행과 열을 나타낸다. 

 

그리고 for문으로 데이터를 빼준다. 

 

그리고 옵션을 선언해주고 

데이터 테이블을 부를 태그를 선언해주면 알아서 그려준다.

 

그리고 JSON방식으로 던져줘야한다. 

 

	@ResponseBody
	@PostMapping("/findDate")
	public List<HashMap<String, Object>> admin_findDate(String date1 , String date2) {
		System.out.println(date1);
		System.out.println(date2);
		List<HashMap<String, Object>> list = service.admin_findDate(date1, date2);
		System.out.println(service.admin_findDate(date1, date2));
		return list;
	}

컨트롤러는 이렇게 선언해주고 리스트라는 이름으로  뷰쪽으로 던져주면 된다. 

 

끝~

반응형
반응형

 

이번에는 회원관리에 대해서 만드는법을 살펴보자 

 

요기 위에 보이는 승인 거절회원 , 추방회원 가입 승인 이렇게 구분되어있다.

 

시나리오는 이렇다

1) 가입을 처음하게 되면 로그인이 되지않는다. 

2) 관리자가 승인을 해줘야 로그인이 된다.

3) 관리자가 승인 거절을 하게 되어 로그인이 안된다.

4) 회원 추방을 한다. 로그인이 안된다. 

 

즉 2번을 제외하고는 로그인이 안되게 막으려고 한다. 

 

그렇게 하려면 

우선 오라클에서 TYPE으로 나누려고 한다.

0 - 대기

1 - 승인

2 - 거절 

3 - 추방 

 

이렇게 4가지 카테고리로 묶으려고 한다. 

 

우선 뷰부터 보자 

 

 <div class="member_list" >
        <table class="admin_board_wrap" id="user-admin">
          <thead class="admin_boardList">
            <th class="admin_board_head">이름</th>
            <th class="admin_board_head">아이디</th>
            <th class="admin_board_head">현재상태</th>
            <th class="admin_board_head">가입일</th>
            <th class="admin_board_head">게시글수</th>
            <th class="admin_board_head">댓글수</th>
            <th class="admin_board_head">가입승인</th>
          </thead>
          <tbody>
          <c:forEach var="vo" items="${userInfo}">
            <tr class="admin_board_content">
              <td class="admin_board_content_nm"><a class="mypageModal user_id" value="${vo.userId}">${vo.userId}</a> </td>
              <td class="admin_board_content_nm">${vo.userName}</td>
              <td class="admin_board_content_nm">
              			<c:choose>
              				<c:when test="${vo.userStatus== 0}">취업준비생</c:when>
              				<c:when test="${vo.userStatus== 1}">직장인</c:when>
              			</c:choose>	
              </td>
              <td class="admin_board_content_nm">${vo.userDate}</td>
              <td class="admin_board_content_nm"><a href="#" class="modal_boardList_admin" data-user-id ="${vo.userId}">${vo.boardCnt}</a></td>
              <td class="admin_board_content_nm"><a href="#" class="modal_reply_admin" data-user-id ="${vo.userId}">${vo.commentCnt}</a></td>
			  <c:choose>
			  	<c:when test="${vo.userPass == 0}">
			  	<td class="admin_board_content_nm">
	                <button data-user-id ="${vo.userId}" type="button" value="승인" class="appro">승인 </button>
	                <button data-user-id ="${vo.userId}" type="button" value="거부" class="deni">거부</button>
                </td>
			  	</c:when>
			  	<c:when test="${vo.userPass == 1}">
			  	<td class="admin_board_content_nm">
	                <button data-user-id ="${vo.userId}" type="button" value="승인" class="userDrop">회원 추방</button>
                </td>
			  	</c:when>
			  	<c:when test="${vo.userPass == 3}">
			  	 	<td>추방회원</td>
			  	</c:when>
			  	<c:when test="${vo.userPass == 2 }">
			  		<td>승인거절회원</td>
			  	</c:when>
			  </c:choose>
            </tr>
            </c:forEach>
          </tbody>
        </table>

 

우선 c:fi로 위에서 정한대로 0 부터 3까지 보여준다. 

 

그다음에 ajax로 컨트롤러로 바꿔준다. 

 

      $('.appro').click(function(){
      	const successId = $(this).data("userId");
    	console.log(successId);
    	// 0 가입대기 , 1.가입승인, 2. 가입거절
    	
    	$.ajax({
    		type : 'post',
    		url : '<c:url value="/admin/successId" />',
    		data : {
        		id : successId,
        	},
        	success : function(data){
        	},error : function(status, error) {
				console.log('에러발생!!');

				console.log(status, error);
			}
        	
    	}); // 아작스 종료
      $('.modal_approve').fadeIn(500);
      });

      // 가입거부 버튼 클릭시 요청 삭제
      $('.deni').click(function(){
        console.log('회원가입거부!');
        // 가입승인 거부됨 메일전송 서비스 만들면 좋을듯
      });
      
      $('.userDrop').click(function() {
		
    	  const dropId = $(this).data("userId");
        	console.log(dropId);
           	$.ajax({
        		type : 'post',
        		url : '<c:url value="/admin/dropId" />',
        		data : {
            		id : dropId,
            	},
            	success : function(data){
            	},error : function(status, error) {
      				console.log('에러발생!!');
      				
      				console.log(status, error);
      			}
  		}); //end ajax

승인아나 추방 버튼을 누르면 

data-id로 아이디를 끌고 온후 

ajax를 동작시킨다. 

 

컨트롤러를 보자 

 

	@ResponseBody
	@PostMapping("/dropId")
	public void dropID(String id) {
		UserService.dropUser(id);
	}
    
    	@ResponseBody
	@PostMapping("/successId")
	public void successId(String id) {
		System.out.println(id);
		System.out.println("open! user sign success Id ajax!");
		UserService.successId(id);
	}
	
	@ResponseBody
	@PostMapping("/failId")
	public void failId(String id) {
		System.out.println(id);
		System.out.println("open! user sign failId Id ajax!");
		UserService.failed(id);
	}

이렇게 한 뒤 매퍼를 보자

   <!-- 가입 승인 -->
   <update id="successId">
      UPDATE user_info
      SET user_pass = 1
      WHERE user_id = #{id}
   </update>
   <!-- 가입 승인 -->
   <update id="failed">
      UPDATE user_info
      SET user_pass = 2
      WHERE user_id = #{id}
   </update>
   <!-- 회원 드롭 -->
      <update id="dropUser">
      UPDATE user_info
      SET user_pass = 3
      WHERE user_id = #{id}
   </update>

이렇게 user_pass를 정해준다. 

 

그럼 가입 승인을 누르면 1로 변경되고

거정을 누르면 2번이되고

추방을 누르면 3번이 된다. 

 

이제 로그인을 막아보자

 

    // 메인 로그인 페이지 빈값확인
      $('.aside_login_btn').click(function(){
        if($('.asideId').val() === ''){
            alert('아이디를 입력하세요.');        
            console.log('아이디를 입력하세요.');
            $('.asideId').focus();
            return;
        } else if($('.asidePw').val() === ''){
            alert('비밀번호를 입력하세요.');
            $('.asidePw').focus();
            return;
        } else {
        	console.log('id, pw 모두 입력함')
           //$('.loginForm').submit(); //ajax로 추후 처리 예정
				console.log('id:'+$('.asideId').val());
				console.log('pw:'+$('.asidePw').val());
				const userId = $('.asideId').val();
			    const userPw = $('.asidePw').val();
			    const userInfo = {"userId":userId, "userPw":userPw};
          $.ajax({
			type : 'post',
			url : '<c:url value="/user/userLogin" />',
			data : JSON.stringify(userInfo),
			dataType:"text",
			contentType : "application/json; charset=UTF-8",
			success : function(data) {
				//checkInput.attr('disabled', false);
				//code = data;
				//console.log(rs);
				if(data === 'idFail'){
					alert('존재하지 않는 회원입니다!');
					//$('.loginForm').submit();
					console.log('db에 존재하지 않는 회원');
				} else if (data === 'pwFail'){
					alert('비밀번호가 틀렸습니다');
					console.log('db에 존재하는 회원, 비번틀림');
				} else if (data === 'wait'){
					alert('가입 승인 중 입니다. 잠시만 기다려 주세요');
				}else if (data === "refusal"){
					alert('가입이 거절 되었습니다.')
				}else if(data === "drop"){
					alert(userId+'님은 로그인 제제 상태입니다. 관리자에게 문의 해주세요.')
				}else {
					alert(userId+'님 반갑습니다.');
					console.log('db에 존재하는 회원, 로긘 성공');
					location.href='/SHY/';
				}
			},
			error : function(status, error) {
				console.log('에러발생!!');
				console.log(userInfo);
				console.log(status, error);
			}
		});

우선 로그인 하는 ajax를 해보자

 

컨트롤러를 확인해보자

	//로그인
		@ResponseBody
		@PostMapping("/userLogin")
		public String userLogin(@RequestBody UserVO vo, HttpSession session) {
			System.out.println("userLogin post");
			System.out.println("갖고온 param: " + vo.getUserId());
			
			BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
			System.out.println(encoder.toString());
			UserVO dbData = service.getInfo(vo.getUserId());
			// 2022 03 27 석현 추가 
			if(dbData.getUserPass() == 0) {
				return "wait";
			}else if(dbData.getUserPass() == 2){
				return "refusal";
			}else if(dbData.getUserPass() == 3){
				return "drop";
			}
			
			if(dbData != null) {
				if(encoder.matches(vo.getUserPw(), dbData.getUserPw())) {
					//로그인 성공 회원을 대상으로 세션 정보를 생성
					session.setAttribute("login", dbData);
					return "loginSuccess";
					
				} else {
					return "pwFail";
				}

			} else {
				return "idFail";
			}

 

우선 user에 대한 세션을 만들어 주고 

user_pass가 0부터 3까지 확인해준다

그다음에 특정 단어를 리턴시켜준다. 

 

그다음

 

			if(data === 'idFail'){
					alert('존재하지 않는 회원입니다!');
					//$('.loginForm').submit();
					console.log('db에 존재하지 않는 회원');
				} else if (data === 'pwFail'){
					alert('비밀번호가 틀렸습니다');
					console.log('db에 존재하는 회원, 비번틀림');
				} else if (data === 'wait'){
					alert('가입 승인 중 입니다. 잠시만 기다려 주세요');
				}else if (data === "refusal"){
					alert('가입이 거절 되었습니다.')
				}else if(data === "drop"){
					alert(userId+'님은 로그인 제제 상태입니다. 관리자에게 문의 해주세요.')
				}else {
					alert(userId+'님 반갑습니다.');
					console.log('db에 존재하는 회원, 로긘 성공');
					location.href='/SHY/';
				}

이렇게 막아준다. 

 

이제 동작해보자 

 

처음 가입하면 관리자 페이지에 이렇게 승인 거부가 뜬다

 

승인을 하면 회원 추방버튼이 생긴다. 

 

로그인이 잘되는걸 알수있다.

 

이제 추방을 눌러보자

 

이렇게 추방회원이라고 못 박혀 나온다. 

 

로그인을 해보자 

 

라고 나온다. 

 

이상 포스팅 끝! 

 

https://github.com/MoonSeokHyun

반응형
반응형

이전에는 내가 만든 사이트에서 회원관리를 만드는걸 리뷰해보았다.

이번에 2번쨰 시간이다.

핀란드에서 부활절 휴일이 끼니.. 개발을 놓게 되었다. 

반성하며 시작합니다.

 

우선 게시글 수와 댓글수를 불러오려면

서브쿼리를 사용하여 불러온다 코드는 다음과 같다. 

   <select id="adminUserList2"
      resultMap="UserInfo">
   select u.*,
    (select count(*) from job_board where board_writer = u.user_id) as board_cnt,
    (select count(*) from job_comment where com_writer = u.user_id) as comment_cnt
    
   from user_info u
   order by u.user_no desc

   </select>

유저의 모든것을 조회하면서 

게시물수와 댓글 갯수를  as __cnt 라는것으로

끌고 온다.

 

이렇게 끌고오면 게시글과 댓글수가 끌고와지는데

 

꼭 VO에 추가해주어야한다. 

그래야 자료를 활용할 수있다. 

 

public class UserVO {

	private int userNo;
	private String userId;
	private String userName;
	private String userPw;
	private String userPh;
	private int userAdr1;
	private String userAdr2;
	private String userAdr3;
	private String userAdr4;
	private int userStatus;
	private String userEmail;
	private String userCompany;
	private int adminType;
	private int userPass;
	private Timestamp userDate;
	private int boardCnt;
	private int commentCnt;

 

private int boardCnt;
private int commentCnt;

을 추가해 주었다. 

 

이렇게 완성되었으면 이제 게시글 수를 눌렀을때 

 

해당 아이디가 쓴 게시물을 쫙 보여주면 된다. 

 

그럼 뷰로 가보자 

 

    <!-- 게시글 모달로 가져오기-->
    <div class="modal_list">
      <div class="modal_boradlist">
        <div class="reply_listWrap">

          <div class="modal_wrap">
            <h3 id="ListName"></h3>
            <p class="modallist">작성한 게시글 수 : 총 01개</p>
            <table class="admin_boardM_wrap" id="comment-admin">
              <thead class="admin_boardMList">
                <th class="admin_boardM_title">글 번호</th>
                <th class="admin_boardM_title">글 제목</th>
                <th class="admin_boardM_title boardleng">작성일</th>
                <th class="admin_boardM_title">조회수</th>
                <th class="admin_boardM_title">좋아요</th>
              </thead>
              </tbody>
              <tbody id="getBoardList">
				<!-- 게시글이 들어갈 공간 -->
              </tbody>
            </table>

이렇게 클릭하면 모달이 뜨게 작성했다. 

이것도 데이터 테이블을 사용하여 

페이징 등을 진행 하였다.

 

이제 js를 보자

 

let str = '';
      // 모달 스크립트 
      $(function () {
    	  $("#user-admin").DataTable();
        // 게시판 모달
        $('.modal_boardList_admin').click(function () {
        	var board_id = $(this).data("userId");
        	console.log(board_id);

        	getList(true, board_id);
          $('.modal_list').fadeIn(500);
        }); // open modal end
        
        function getList(reset, board_id) {
        	
        	if(reset) {
        		str = '';
        	}
        	
        	$.ajax({
        		type : 'post',
        		url : '<c:url value ="/admin/getUserBoardList"/>',
                data : {
                	board_writer : board_id,
                	},
        		dataType : "json",
        		success : function(data) {
					for(var i = 1 in data){
						console.log(data[i].board_title);
						str += "<tr class='admin_boardM_content'>"
						str += "<td class='admin_boardM_nm'><a href='#'>"+data[i].board_no+"</a></td>"
						str += "<td class='admin_boardM_nm'><a href='#'>"+data[i].board_title+"</a></td>"
						str += "<td class='admin_boardM_nm'><a href='#'>"+timeStamp(data[i].board_regdate)+"</a></td>"
						str += "<td class='admin_boardM_nm'>"+data[i].board_hit+"</td>"
						str += "<td class='admin_boardM_nm'>"+data[i].board_like+"</td>"
						str += "</tr>"
					}
					$('#ListName').html(board_id + '님의 작성 게시물')
					$('#getBoardList').html(str); 
					$("#comment-admin").DataTable();
				},error : function(status, error) {
					console.log('에러발생!!');
					console.log(status, error);
				}

	          });//ajax 종료
		}

 

우선 json으로 던질 아이디 값을 가져오기 위해

 

 <td class="admin_board_content_nm"><a href="#" class="modal_boardList_admin" data-user-id ="${vo.userId}">${vo.boardCnt}</a></td>

var board_id = $(this).data("userId");로 아이디 값을 가져 온다. 

 

가져 온뒤 본격적으로 ajax를 작성한다.

<select id="getUserBoardList" resultType="com.community.shy.board.command.BoardVO">
         select * from job_board where board_writer = #{board_writer}
      </select>

 

해당 쿼리문을 보자 

 

 

 

json으로 해당 아이디를 컨트롤러로 전하고 

모든 해당 게시물을 조회하면 된다. 

 

url에 있는 getUserBoardList로 가보자 

 

컨트롤러 

	@ResponseBody
	@PostMapping("/getUserBoardList")
	public List<BoardVO> getUserBoardList(String board_writer) {
		System.out.println("open! user boardList ajax!");
		System.out.println("조회할 회원 아이디 : " + board_writer);
		List<BoardVO> list = service.getUserBoardList(board_writer);
		
		return list;
	}

 

어드민 컨트롤러는 일반 컨트롤러로 해서 rest다입인 responsebody를 붙혀준다. 

 

그냥 조회만 할껀데 왜 포스트를 썻지.. 

다음에 하면 아마 get으로 할꺼같다. 

 

그럼 이제 컨트롤러 -> 서비스 -> 매퍼 -> 컨트롤러 -> 뷰 순으로 돌아가서 

해당 아이디의 모든 데이터를 받아볼수 있을것이다. 

 

 

요론식으로 

 

그다음 뷰에서 json으로 받았으면 

화면에 뿌려주게 반복문을로 받아준다. 

 

str 이라는 빈 변수를 선언하여 

모달에 들어갈 내용들을 적어준다.

그러면 리스트에 담긴 수를 다 쏟아 낼 것이다. 

 

댓글도 똑같기 때문에 별 다르게 할 건 없을거같다.

 

다음에는 회원관리에 대해서 말해보려고 한다.

 

이제 그만쉬고 ㅋㅋ 다시 빡코딩 하자 

5월 15일 전까지 만들고 있는 사이트 다완성하자

 

파이팅 ㅋㅋ 

 

https://github.com/MoonSeokHyun

반응형
반응형

다중게시판 및 댓글 및 CK에디터까지 블로그에 글을 썻다

이제 남은것은 거의 .. 관리자페이지인거 같다. 

 

위와 같은 관리자 페이지 이며 오늘은 회원 관리 만드는 법에 대해서 알아보고자 한다. 

 

회원관리는 위와 같은 페이지로 이루어 져있으며

데이터 테이블을 통해 검색 및 페이지네이션까지 구현하였다. 

기능을 살펴보자면 

 

이름을 클릭하면 해당하는 회원 정보를 볼 수있다. 

 

게시글 수 및 댓글 수를 클릭하면 해당 아이디가 쓴 게시글 및 댓글을 볼 수 있다. 

 

다 모달을 통해 볼 수 있다. 그렇다 모달은 참 귀찮다. ;;

 

1. 회원 정보

회원 정보를 볼 수 있음 

 

2. 작성 게시물

3. 쓴 댓글

 

4. 회원 관리

가입 승인 , 가입 대기, 가입거절 , 회원 추방

이렇게 4개를 가지고  회원 을 가입한다.

 

회원이 처음 가입하면 대기 상태이며

관리자가 확인 후에 가입 승인을 해준다. 

 

같은 화면에서 드롭시킬 수도있다. 

 

자 이제 만들어 보자 

 

관리자 같은경우는 따로 테이블을 제작 할 필요는 없다.

유저를 만들때 관리자는 1 일반유저는 0 이렇게 구분해 두었기 떄문에

 

일반 유저는 어드민페이지에 접근할 수없도록 세션값으로 조정해준다. 

 

각 기능 별로 담기는 너무 길이가 길어지니 컨트롤러 리뷰 뷰 리뷰 이런식으로 해야겠다.. 

 


1. 컨트롤러

package com.community.shy.board.controller;

import java.sql.Timestamp;
import java.util.HashMap;
import java.util.List;

import org.apache.ibatis.annotations.Mapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.community.shy.board.JobBoard.service.IBoardService;
import com.community.shy.board.JobComment.service.ICommentService;
import com.community.shy.board.command.BoardVO;
import com.community.shy.board.command.CommentVO;
import com.community.shy.user.UserVO;
import com.community.shy.user.service.IUserService;

@Controller
@RequestMapping("/admin")
public class AdminController {
	
	
	@Autowired
	private IBoardService service; 
	
	@Autowired
	private IUserService UserService;
	
	@Autowired ICommentService comService;

	@GetMapping("/admin_main")
	public void main(Model model) {
		System.out.println("메인 페이지로 이동");
		model.addAttribute("boardList", service.getAdminList());
		model.addAttribute("userInfo",UserService.adminUserList());
		
	}
	
	@GetMapping("/admin_boardList")
	public void mainList(Model model) {
		System.out.println("어드민메인 게시판 리스트");
		model.addAttribute("allBoard", service.getAllboard());
	}
	
	// 어드민 회원 관리
	@GetMapping("/admin_userList")
	public void user_list(Model model) {
		//회원 기본정보 페이징(x)
		System.out.println("/admin_userList 요청");
		List<UserVO> list = UserService.adminUserList2();
		model.addAttribute("userInfo",list);
		
		
	};
	
	@ResponseBody
	@PostMapping("/getuserInfo")
	public UserVO getuserInfo(String id) {
		System.out.println("유저 인포 아작스");
		UserVO user = UserService.getInfo(id);
		return user;
	}
	
	@ResponseBody
	@PostMapping("/getUserBoardList")
	public List<BoardVO> getUserBoardList(String board_writer) {
		System.out.println("open! user boardList ajax!");
		System.out.println("조회할 회원 아이디 : " + board_writer);
		List<BoardVO> list = service.getUserBoardList(board_writer);
		
		return list;
	}
	@ResponseBody
	@PostMapping("/getCommentList")
	public List<CommentVO> getCommentList(String com_writer){
		System.out.println("open! user Comment List ajax!");
		System.out.println("조회할 회원 아이디 : " + com_writer);
		List<CommentVO> list = comService.getComList(com_writer);
		System.out.println(list);
		return list;
	}
	
	@ResponseBody
	@PostMapping("/successId")
	public void successId(String id) {
		System.out.println(id);
		System.out.println("open! user sign success Id ajax!");
		UserService.successId(id);
	}
	
	@ResponseBody
	@PostMapping("/failId")
	public void failId(String id) {
		System.out.println(id);
		System.out.println("open! user sign failId Id ajax!");
		UserService.failed(id);
	}
	
	@ResponseBody
	@PostMapping("/deleteBoard")
	public void deleteBoard(int board_no) {
		System.out.println("삭제할 게시물 : " + board_no);
		service.JBoardDelete(board_no);
	}
	
	@GetMapping("/admin_dataTotal")
	public void admin_dataTotal(Model model) {
		model.addAttribute("allTotal", service.getAllTotal());
	}
	
	@ResponseBody
	@PostMapping("/findDate")
	public List<HashMap<String, Object>> admin_findDate(String date1 , String date2) {
		System.out.println(date1);
		System.out.println(date2);
		List<HashMap<String, Object>> list = service.admin_findDate(date1, date2);
		System.out.println(service.admin_findDate(date1, date2));
		return list;
	}
	
	@ResponseBody
	@PostMapping("/dropId")
	public void dropID(String id) {
		UserService.dropUser(id);
	}
}

우선 main으로 이동시켜 주어 model 객체로 

유저리스트와 게시판을 실시간으로 업데이트 해준다. 

 

그 뒤 어드민 페이지로 이동해 모든 회원 정보를 불러온다. 

 

   <select id="adminUserList2"
      resultMap="UserInfo">
   select u.*,
    (select count(*) from job_board where board_writer = u.user_id) as board_cnt,
    (select count(*) from job_comment where com_writer = u.user_id) as comment_cnt
    
   from user_info u
   order by u.user_no desc

   </select>

매퍼에서 이렇게 가져올 경우 

VO도 수정해 주어야 한다 서브쿼리로 board_cnt와 comment_cnt가 추가 되어

불러오려면

 

	private int userNo;
	private String userId;
	private String userName;
	private String userPw;
	private String userPh;
	private int userAdr1;
	private String userAdr2;
	private String userAdr3;
	private String userAdr4;
	private int userStatus;
	private String userEmail;
	private String userCompany;
	private int adminType;
	private int userPass;
	private Timestamp userDate;
	private int boardCnt;
	private int commentCnt

userVO에 서브쿼리에 선언문을 추가해준다. 

 

그 뒤 서비스와 매퍼를 거쳐 

리스트 타입으로 받아 주어 모델로 해당 뷰에 뿌려준다. 

 

      <div class="member_list" >
        <table class="admin_board_wrap" id="user-admin">
          <thead class="admin_boardList">
            <th class="admin_board_head">이름</th>
            <th class="admin_board_head">아이디</th>
            <th class="admin_board_head">현재상태</th>
            <th class="admin_board_head">가입일</th>
            <th class="admin_board_head">게시글수</th>
            <th class="admin_board_head">댓글수</th>
            <th class="admin_board_head">가입승인</th>
          </thead>
          <tbody>
          <c:forEach var="vo" items="${userInfo}">
            <tr class="admin_board_content">
              <td class="admin_board_content_nm"><a class="mypageModal user_id" value="${vo.userId}">${vo.userId}</a> </td>
              <td class="admin_board_content_nm">${vo.userName}</td>
              <td class="admin_board_content_nm">
              			<c:choose>
              				<c:when test="${vo.userStatus== 0}">취업준비생</c:when>
              				<c:when test="${vo.userStatus== 1}">직장인</c:when>
              			</c:choose>	
              </td>
              <td class="admin_board_content_nm">${vo.userDate}</td>
              <td class="admin_board_content_nm"><a href="#" class="modal_boardList_admin" data-user-id ="${vo.userId}">${vo.boardCnt}</a></td>
              <td class="admin_board_content_nm"><a href="#" class="modal_reply_admin" data-user-id ="${vo.userId}">${vo.commentCnt}</a></td>
			  <c:choose>
			  	<c:when test="${vo.userPass == 0}">
			  	<td class="admin_board_content_nm">
	                <button data-user-id ="${vo.userId}" type="button" value="승인" class="appro">승인 </button>
	                <button data-user-id ="${vo.userId}" type="button" value="거부" class="deni">거부</button>
                </td>
			  	</c:when>
			  	<c:when test="${vo.userPass == 1}">
			  	<td class="admin_board_content_nm">
	                <button data-user-id ="${vo.userId}" type="button" value="승인" class="userDrop">회원 추방</button>
                </td>
			  	</c:when>
			  	<c:when test="${vo.userPass == 3}">
			  	 	<td>추방회원</td>
			  	</c:when>
			  	<c:when test="${vo.userPass == 2 }">
			  		<td>승인거절회원</td>
			  	</c:when>
			  </c:choose>
            </tr>
            </c:forEach>
          </tbody>
        </table>

 

우선 userInfo로 모델로 뿌려 주어 jstl로 반복문을 돌려주면 

아래와 같이 쫙쫙 뿌려준다. 여기서 데이터테이블로 테이블을 구성하여

페이징 을 구현 하였다. 

가입 승인 이쪽은 

처음 가입할경우 0

가입승인 : 1 

가입거절 : 2

회원추방 : 3

 

이렇게 코드가 작성되어있기 떄문에 C:IF로 처리 되어있다. 

 

이제 이름을 선택하여 AJAX로 모달에 데이터를 뿌려주자.

 

$('.mypageModal').click(function () {
          $('.mypage_modal').fadeIn(500);
          var Id = $(this).attr('value');
          console.log(Id);
          // 아이디 값 불러옴 
          
          $.ajax({
        	type : 'post',
        	url: '<c:url value="/admin/getuserInfo" />',
        	data : {
        		id : Id,
        	},
        	dataType:"json",
        	success : function(data){
        		console.log(data.userName);
        		console.log(data.userId);
        		$("input[name='name']").val(data.userName);
        		$("input[name='id']").val(data.userId);
        		$("input[name='phone']").val(data.userPh);
        		$("input[name='addr1']").val(data.userAdr3);
        		$("input[name='addr2']").val(data.userAdr2);
        		$("input[name='addr3']").val(data.userAdr4);
        		$("input[name='addr_num']").val(data.userAdr1);
        		$(".memInfo").html(data.userName+"님의 회원 정보");
        	},error : function(status, error) {
				console.log('에러발생!!');

				console.log(status, error);
			}
        	
        	
          })//ajax 종료

우선

   var Id = $(this).attr('value');로 해당 아이디를 찍으면 

Value값을 불러오게 하자 그 뒤 ajax를 실행 시킨다. 

 

컨트롤러 getuserInfo를 작성해보자.

	@ResponseBody
	@PostMapping("/getuserInfo")
	public UserVO getuserInfo(String id) {
		System.out.println("유저 인포 아작스");
		UserVO user = UserService.getInfo(id);
		return user;
	}

 

user 타입으로 받아야 하기 떄문에 userVO 타입으로 선언해주고

아까 찍은 파라미터를 넘겨준다. 

 

이제 매퍼를 보자

 

<select id="getInfo" resultMap="UserInfo">SELECT *FROM user_info WHERE user_id = #{id} </select>

로 불러왔으면 컨트롤러에서 이제 user이름으로 리턴을 해준다. 

 

ajax라 따로 모델로 넘겨주거나 하지않는다. 

 

다시 ajax를 보면 

 

success : function(data){
        		console.log(data.userName);
        		console.log(data.userId);
        		$("input[name='name']").val(data.userName);
        		$("input[name='id']").val(data.userId);
        		$("input[name='phone']").val(data.userPh);
        		$("input[name='addr1']").val(data.userAdr3);
        		$("input[name='addr2']").val(data.userAdr2);
        		$("input[name='addr3']").val(data.userAdr4);
        		$("input[name='addr_num']").val(data.userAdr1);
        		$(".memInfo").html(data.userName+"님의 회원 정보");

data로 user의 정보를 받기 떄문에 

모달 input에 넣어 주면된다. 

 

이렇게 하면 우선 ajax로 마이페이지 끗 :) 

 

다음은 게시판을 해보자 게시판이나 댓글이나 똑같으니 

게시판만 하는법을 정리해보자 

 

게시판을 불러오는 ajax이다. 

$('.modal_boardList_admin').click(function () {
        	var board_id = $(this).data("userId");
        	console.log(board_id);

        	getList(true, board_id);
          $('.modal_list').fadeIn(500);
        }); // open modal end
        
        function getList(reset, board_id) {
        	
        	if(reset) {
        		str = '';
        	}
        	
        	$.ajax({
        		type : 'post',
        		url : '<c:url value ="/admin/getUserBoardList"/>',
                data : {
                	board_writer : board_id,
                	},
        		dataType : "json",
        		success : function(data) {
					for(var i = 1 in data){
						console.log(data[i].board_title);
						str += "<tr class='admin_boardM_content'>"
						str += "<td class='admin_boardM_nm'><a href='#'>"+data[i].board_no+"</a></td>"
						str += "<td class='admin_boardM_nm'><a href='#'>"+data[i].board_title+"</a></td>"
						str += "<td class='admin_boardM_nm'><a href='#'>"+timeStamp(data[i].board_regdate)+"</a></td>"
						str += "<td class='admin_boardM_nm'>"+data[i].board_hit+"</td>"
						str += "<td class='admin_boardM_nm'>"+data[i].board_like+"</td>"
						str += "</tr>"
					}
					$('#ListName').html(board_id + '님의 작성 게시물')
					$('#getBoardList').html(str); 
					$("#comment-admin").DataTable();
				},error : function(status, error) {
					console.log('에러발생!!');
					console.log(status, error);
				}

	          });//ajax 종료
		}

우선 var board_id = $(this).data("userId"); 

제이쿼리로 아이디 값을 지목을 해주고 

이대로 바로 ajax를 실행할 경우 

아이디를 누를 경우 계속 중첩해서 나오기 떄문에 닫기버튼을 누르거나 아이디를 클릭

할때 한번 초기화 해주는 것이 중요하다. 

 

이것을 getList(true, board_id);로 부르자

 

우선 reset이 true라면 str을 초기화 해주자 

그럼 중첩되지 않고 기존 데이터를 날리고 새롭게 추가 될 것이다. 

 

그 후 ajax를 해주면 된다. 

좀 노가다 긴한데 댓글이랑 비슷하다.

 

리스트 타입으로 전달받은 data를data가 끝날때 까지 반복한다. 

 

그럼 이제 

getUserBoardList 컨트롤러로 가보자

 

	@ResponseBody
	@PostMapping("/getUserBoardList")
	public List<BoardVO> getUserBoardList(String board_writer) {
		System.out.println("open! user boardList ajax!");
		System.out.println("조회할 회원 아이디 : " + board_writer);
		List<BoardVO> list = service.getUserBoardList(board_writer);
		
		return list;
	}

조회할 아이디를 ajax로 보내주고 

매퍼를 보자

 

    <select id="getUserBoardList" resultType="com.community.shy.board.command.BoardVO">
         select * from job_board where board_writer = #{board_writer}
      </select>

매퍼를 보면 참 간단하다. 이 아이디로 조회된 것들을 모두 다 가져온다. 

 

그럼 실행 되면서 해당 아이디로 조회된 모든 값을 전달 해주고 

모달에 제이쿼리 함수인 html()로 추가해주면 된다.

 

실행 순서는 다음과 같다. 

 

1) 아이디를 누른다.

이때 getList에 reset이 초기화 되면서 빈 문자열로 만들어준다.

2) 아이디값을 ajax로 받아온다. 

3) ajax로 받아온 값을 컨트롤러로 전달한다. 

4) 서비스와 매퍼를 거쳐 매퍼에서 조회된 값을 다시 컨트롤러로 전달한다.

5) 컨트롤러에서 다시 ajax로 리턴한다. 

6) 리턴된 값은 success에 값인 data로 받는다.

7) data에는 해당 아이디의 조회된 값을 가지고 있으니 반복문을 돌려 다 털어준다. 

 8) html()로 추가해 주면 끝난다. 

 

 

이렇게 하면 종료된다. 

 

너무 길어서 2부로 제작해야 겟다. .

 

https://github.com/MoonSeokHyun/JobJob_community

 

반응형
반응형

이번 시간에는 이전에 프로젝트 때 작업 했던 

위 와같은 댓글이 달리도록 한번 작성해보자 

 

그럼 Let's GO 

 


1.  댓글 테이블 제작 및 vo 클래스 제작

 

데이터 베이스 같은경우 오라클을 사용하였다. 

 

import java.sql.Timestamp;

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;

@Getter
@Setter
@ToString
public class CommentVO {
	
	private int com_no;
	private String com_writer;
	private String com_content;
	private int com_like;
	private int com_hate;
	private String re_com;
	private int com_type;
	private Timestamp com_regdate;
	private int com_bno;
}

 

위 와같이 코드가 작성되고 컬럼명은 VO와 동일하게 제작했댜.

 


서비스와 매퍼 객체를 만들어보자 

 

public interface ICommentService {
	
	
	void CommentRegist(CommentVO vo); //댓글 등록
	List<CommentVO> getList(int com_bno); //목록 요청
	int getTotal(int com_bno); //댓글 개수
	List<CommentVO> myRecord(String writer);
	void commentDelete(CommentVO vo);
	
	List<CommentVO> getComList(String com_wrtier); //어드민용 회원 댓글 불러오긔

}

인터페이스 서비스와 매퍼객체 똑같이 만들어준다. 

 

그 뒤 서비스를 포함한 클래스를 만들어준다. 

 

package com.community.shy.board.JobComment.service;

import java.util.List;

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

import com.community.shy.board.JobComment.mapper.ICommentMapper;
import com.community.shy.board.command.CommentVO;
@Service
public class CommentService implements ICommentService {

	@Autowired
	private ICommentMapper mapper;
	
	@Override
	public void CommentRegist(CommentVO vo) {
		mapper.CommentRegist(vo);

	}

	@Override
	public List<CommentVO> getList(int com_bno) {
		return mapper.getList(com_bno);
	}

	@Override
	public int getTotal(int com_bno) {
		// TODO Auto-generated method stub
		return mapper.getTotal(com_bno);
	}

	@Override
	public List<CommentVO> myRecord(String writer) {
		return mapper.myRecord(writer);
	}

	@Override
	public void commentDelete(CommentVO vo) {
		mapper.commentDelete(vo);
		
	}
	
	@Override
	public List<CommentVO> getComList(String com_wrtier) {
		return mapper.getComList(com_wrtier);
	}

}

오늘 필요한 메소드는 CommentRegist 와 getList , getTotal 까지 이다. 

 

 


컨트롤러 및 마이바티스에 들어가는 매퍼를 제작해보자 

 

매퍼 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="com.community.shy.board.JobComment.mapper.ICommentMapper">
  	
  	<insert id="CommentRegist">
  		insert into job_comment(com_no,com_writer,com_content,com_like,com_hate,re_com,com_type,com_bno)
		values (COMMENT_SEQ.nextval ,#{com_writer},#{com_content},0,0,1,1,#{com_bno})
  	</insert>
  	
  	<select id="getTotal" resultType="int">
  		select count(*) from job_comment where com_bno = #{com_bno}
  	</select>
  	
  	<select id="getList" resultType="com.community.shy.board.command.CommentVO">
  		select * from job_comment where com_bno = #{com_bno}
  	</select>
  	
  	<select id="myRecord" resultType="com.community.shy.board.command.CommentVO">
		SELECT * FROM job_comment
		WHERE com_writer = #{writer}
	</select>
	
	<delete id="commentDelete">
		DELETE FROM job_comment
		WHERE com_writer = #{com_writer} AND com_content = #{com_content}
	</delete>
	
	<select id="getComList" resultType="com.community.shy.board.command.CommentVO">
        select * from job_comment where com_writer = #{com_writer}
     </select>
	
  </mapper>
@RestController
@RequestMapping("/Comment")
public class CommentController {
	
	@Autowired
	private ICommentService service;
	
	@PostMapping("/InsertComment")
	public String InsertComment(@RequestBody CommentVO vo,HttpSession session) {
		System.out.println("댓글 등록 통신 성공");
		if(session.getAttribute("login") == null) {
			return "fail";
		} else {
			System.out.println("로긘함. 스크랩 진행");
			
			service.CommentRegist(vo);
			System.out.println("댓글 등록 서비스 성공");
			return "InsertSuccess";
		}
	}

	@GetMapping("/CommentList/{com_bno}")
	public Map<String, Object> getList(@PathVariable int com_bno, Model model) {
		System.out.println("댓글 목록 컨트롤러 동작");
		List<CommentVO> list = service.getList(com_bno);
		int total = service.getTotal(com_bno);
		
		ModelAndView view = new ModelAndView();
		System.out.println("댓글 갯수 " + service.getTotal(com_bno));
		view.setViewName("/board/JBoardList");
		Map<String, Object> map = new HashMap<>();
		map.put("list", list);
		map.put("total", total);
		
		return map;
	}

컨트롤러 같은경우에 ajax로 동작시키려고 한다.

그렇기 떄문에 RestControolaer를 활용하자 

 

그 후 세션 객체를 활용 하여 로그인 검증 한번 해주고

댓글 등록에 대한 로직이 돌아가 도록 서비스 객체에서 댓글 등록 인서트문 을 돌려준다. 

 

이제 jsp를 보자! :) 

 

 

                <div class="comment-box">
                    
   		                 <div class="comment-count">댓글 <span id="count">0</span></div>

   		                 	   <!-- <span class="c-icon"><i class="fa-solid fa-user"></i>  -->
   		                 <div class="comment-name">
	                        <span class="anonym">작성자 : 
	                    	    <input type="text" class="form-control" id="com_writer" placeholder="이름" name ="com_writer" value='${login.userId}' readonly  style="width: 100px; border:none;">
	                        </span>
	                      </div>   
	                        	
	                        <!-- </span> -->
                     <!--<img src="/익명.jpg" width ="50px" alt="My Image"><!-->
                    <div class="comment-sbox">
                        <textarea class="comment-input" id="com_content" cols="80" rows="2" name="com_content" ></textarea>
                        <!-- <span class="com-function-btn" type="hidden">
                            
                            <a href="#"><i class="fa-solid fa-pen-to-square"></i></a>
                            <a href="#"><i class="fa-solid fa-trash-can"></i></a>
                         </span> -->
                    </div>
                    	<div class="regBtn">
                    		<button id="Comment_regist"> 댓글등록</button>
                    	 </div>

작성하면 대략 

이런 화면을 가진 창이 나타내게 된다. 

 

그 후 댓글 등록을 누르게 되면  다른 div 박스 안에 계속 list가 채워 지는 형식으로 진행 할 것이다. 

 

<div class="comment_Box" style="border:1px solid gray;"> <!-- 댓글이 들어갈 박스 -->

	                </div>

이제 ajax 를 작성해보자 

 

$('#Comment_regist').click(function() {
			
   			//Json으로 전달할 파라미터 변수선언
   			const com_bno = ${board_no};
   			const com_writer = $('#com_writer').val();
   			const com_content = $('#com_content').val();
   			
   			console.log(com_bno);
   			console.log(com_writer);
   			console.log(com_content);
   		
   			if(com_writer == ''){
   				alert('로그인 후 이용해주세요');
   				return;
   			}else if(com_content == '') {
   				alert('내용을 입력하세요');
   			}
   			
   			$.ajax({
   				type:'post',
   				url:'<c:url value="/Comment/InsertComment"/>',
   				data: JSON.stringify(
   					{
   						"com_bno":com_bno,
   						"com_writer":com_writer,
   						"com_content":com_content
   					}		
   				),
   				contentType: 'application/json',
   				success:function(data){
   					console.log('통신성공' + data);
   					if(data === 'InsertSuccess') {
   						alert('댓글 등록이 완료되었습니다.');
   						console.log('댓글 등록 완료');
   						$('#com_writer').val(com_writer);
   	   					$('#com_content').val('');
   	   					getList();
   					} else {
   						alert('로그인 이후 이용해주시기 바랍니다.');
   						console.log('댓글 등록 실패');
   					}
   				},
   				error:function(){
   					alert('통신실패');
   				}
   			});// 댓글 비동기 끝
   			
		});// 댓글등록 이벤트 끝
		
		getList();

우선 Json으로 전달할 파라미터를 const로 변수 선언을 해준다. 

이것이 이제 컨트롤러로 들어가 매퍼를 거쳐 디비에 저장될 값이다. 

 

그후 검증을 통해 빈값 체크 및 로그인을 하지 않았을 경우 등을 걸러준다. 

그 후 ajax를 통해 입력 받은 데이터를 컨트롤러로 넘겨준다. 

 

이때 ajax를 통해 getList라는 메소드가 ㄴ발동 되게 되는데 이것은 리스트를 불러오는 것이다 

작성된 글을 실시간으로 비동기 식으로 보여주어  페이지 로딩없이 바로 보여준다. 

 

getList는 getJson으로 해보자

 

ajax와 getJson의 차이점은 

async 옵션은 기본적으로 true 가 default 인데, false 로 하면 백그라운드로 진행하는게 아니라 순차적으로 진행되어  제대로된 .ajax 를 사용하는게 아닐지 모르지만 화면을 보는 관점에서는 더자연스럽게 느껴진다.

 

     또한, 백그라운드로 진행하면 안되는 작업을 할 때는 async옵션을 false로 주어야 한다.

 

 

		function getList() {
			
			const com_bno = ${board_no};
			const com_writer = $('#com_writer').val();
   			const com_content = $('#com_content').val();
   			/* const com_no = ${com}; */
			$.getJSON(
				"<c:url value='/Comment/CommentList/'/>"+com_bno,
				function(data) {
					if(data.total > 0){
						var list = data.list;
						
						var comment_html = "<div>";
						
						$('#count').html(data.total);
						for(i = 0;i < list.length;i++){
							var content = list[i].com_content;
							var writer = list[i].com_writer;
							comment_html += "<div><span id='com_writer'><strong>" + writer + "</strong></span><br/>";
							comment_html += "<span id='com-content'>" + content + "</span><br>";
							if(writer === $("#com_writer").val()){
								 comment_html += "<span id='delete' style='cursor:pointer;' data-id ="+content+">[삭제]</span><br></div><hr>";
								 
							}
							else{
								comment_html += "</div><hr>";
							}
						}
						
						$(".comment_Box").html(comment_html);
						
						
					}
					else{
						var comment_html = "<div>등록된 댓글이 없습니다.</div>";
						$(".comment_Box").html(comment_html);
					}
			
				
				}
				);//getJson



getJson도 우선 글을 불러오기 위해 글 번호를 받는다. 

그 뒤에 컨트롤러에 접근하기위해 글 번호를 묻혀 보낸다. 

이떄 데이터 크기가 0코다 클경우로 설정하여 

 

댓글이 0개 일시 등록된 댓글이 없다고 표기해준다. 

 

그 후 컨트롤러에서 뿌려진 정보를 data 반복문을 통해 

이 글 번호에 등록된 댓글을 계속 뿌려주고 

이때 계속 += div asdasd .</div>

이렇게 계속 html 코드가 이어지도록 반복문을 작성한뒤 

 

제이쿼리 html() 로 붙여 넣어주면 댓글 작성이 끝나게 된다. 

 

https://github.com/MoonSeokHyun/JobJob_community

 

GitHub - MoonSeokHyun/JobJob_community

Contribute to MoonSeokHyun/JobJob_community development by creating an account on GitHub.

github.com

 

 

반응형
반응형

오늘은 게시판 별 카테고리(type)을 주어 다중 게시판을 만들어 보고자 한다. 

 

1. Sql 테이블 생성

 

테이블 생성

 

다중게시판을 위해 Board_type으로 게시판을 나눈다. 

 

2. VO객체 생성

 

public class BoardVO {
	private int board_no;
	private String board_title;
	private String board_writer;
	private String board_content;
	private int board_hit;
	private int board_like;
	private int board_hate;
	private String board_img;
	private String board_img_path;
	private int board_type;
	private Timestamp board_regdate;
}

vo 객체 생성 뒤 페이징 및 검색을 위한 객체 생성

 

@Getter
@Setter
public class PageVO {

	//사용자가 선택한 페이지 정보를 담을 변수.
	private int pageNum;
	private int countPerPage;
	
	//검색에 필요한 데이터를 변수로 선언.
	private String keyword;
	private String condition;
	
	public PageVO() {
		this.pageNum = 1;
		this.countPerPage = 5;
	}
	
}

페이징을 위한 다음 이전 등 버튼 개수를 위한 클래스 제작

 

@Setter
@Getter
@ToString
public class PageCreator {
	
	private PageVO paging;
	private int articleTotalCount;
	private int endPage;
	private int beginPage;
	private boolean prev;
	private boolean next;
	
	private final int buttonNum = 5;
	
	
	private void calcDataOfPage() {
		
		endPage = (int) (Math.ceil(paging.getPageNum() / (double) buttonNum) * buttonNum);
		
		beginPage = (endPage - buttonNum) + 1;
		
		prev = (beginPage == 1) ? false : true;
		
		next = articleTotalCount <= (endPage * paging.getCountPerPage()) ? false : true;
		
		if(!next) {
			endPage = (int) Math.ceil(articleTotalCount / (double) paging.getCountPerPage()); 
		}
		
	}
	
	//컨트롤러가 총 게시물의 개수를 PageCreator에게 전달한 직후에 
	//바로 페이징 버튼 알고리즘이 돌아갈 수 있도록 setter를 커스텀.
	public void setArticleTotalCount(int articleTotalCount) {
		this.articleTotalCount = articleTotalCount;
		calcDataOfPage();
	}

}

 

jsp (view) 제작

 

<body>
	<header id="header">
		<%@ include file="../include/header.jsp"%>
	</header>



	<section>
		<div class="body-box">
			<div class="row">

				<div class="titlebox">
					<c:choose>
						<c:when test="${type == 1}">
							<h2>사기업게시판</h2>
						</c:when>
						<c:when test="${type == 2}">
							<h2>공기업게시판</h2>
						</c:when>
						<c:when test="${type == 3}">
							<h2>아시아게시판</h2>
						</c:when>
						<c:when test="${type == 4}">
							<h2>유럽게시판</h2>
						</c:when>
						<c:when test="${type == 5}">
							<h2>남미게시판</h2>
						</c:when>
						<c:when test="${type == 6}">
							<h2>북미게시판</h2>
						</c:when>
						<c:when test="${type == 7}">
							<h2>아프리카게시판</h2>
						</c:when>
						<c:when test="${type == 8}">
							<h2>국가자격증게시판</h2>
						</c:when>
						<c:when test="${type == 9}">
							<h2>민간자격증게시판</h2>
						</c:when>
						<c:when test="${type == 10}">
							<h2>어학게시판</h2>
						</c:when>
						<c:when test="${type == 11}">
							<h2>자유게시판</h2>
						</c:when>
						<c:when test="${type == 12}">
							<h2>취뽀게시판</h2>
						</c:when>
						<c:when test="${type == 13}">
							<h2>취업게시판</h2>
						</c:when>
						<c:when test="${type == 14}">
							<h2>자격증게시판</h2>
						</c:when>
						<c:when test="${type == 15}">
							<h2>자소서게시판</h2>
						</c:when>



					</c:choose>
				</div>
				<hr>



				<div class="search-wrap">

					<div id="search_box">
						<form action=<c:url value="/board/JBoardList"/>>
							<input type="hidden" name="board_type" value="${type}" />
							<div class="search-wrap clearfix">
								<select class="form-control search-select" name="condition">
									<option value="board_title"
										${pc.paging.condition == 'board_title' ? 'selected' : ''}>제목</option>
									<option value="board_content"
										${pc.paging.condition == 'board_content' ? 'selected' : ''}>내용</option>
									<option value="board_writer"
										${pc.paging.condition == 'board_writer' ? 'selected' : ''}>작성자</option>
								</select> <input type="text" name="keyword"
									class="form-control search-input" value="${pc.paging.keyword}">
								<button type="submit" class="btn btn-info search-btn">검색</button>
							</div>
						</form>
					</div>
				</div>
				<table>
					<colgroup>

						<col class="no">
						<col class="title">
						<col class="writer">
						<col class="date">
						<col class="count">
						<col class="like">
					</colgroup>
					<thead>
						<tr>

							<th>번호</th>
							<th>제목</th>
							<th>작성자</th>
							<th>작성일</th>
							<th>조회</th>
							<th>추천</th>
						</tr>
					</thead>
					<tbody>

						<c:forEach var="vo" items="${boardList}">
							<tr>
								<td>${vo.board_no}</td>
								<td><a href="<c:url value ='/board/JBoardDetail?board_no=${vo.board_no}&board_type=${type}'/>">${vo.board_title} (${count})</a></td>
								<td><a href="#" id="modal-writer1">${vo.board_writer}</a></td>
								<td>${vo.board_regdate}</td>
								<td>${vo.board_hit}</td>
								<td>${vo.board_like}</td>
							</tr>
						</c:forEach>



					</tbody>
				</table>
				<a href=<c:url value="/board/JBoardWrite?board_type=${type}"/> class="myButton">글쓰기</a>



				<form action=<c:url value="/board/JBoardList?board_type=${type}"/>
					name="pageForm">
					<div class="text-center clearfix">
						<hr>
						<ul class="pagination" id="pagination">
							<c:if test="${pc.prev}">
								<li><a href="#" data-pageNum="${pc.beginPage-1}">이전</a></li>
							</c:if>

							<c:forEach var="num" begin="${pc.beginPage}" end="${pc.endPage}">
								<li class="${pc.paging.pageNum == num ? 'active' : ''}"><a
									href="#" data-pageNum="${num}">${num}</a></li>
							</c:forEach>

							<c:if test="${pc.next}">
								<li><a href="#" data-pageNum="${pc.endPage+1}">다음</a></li>
							</c:if>
						</ul>

						<!-- 페이지 관련 버튼을 클릭 시 같이 숨겨서 보낼 값 -->
						<input type="hidden" name="board_type" value="${type}">
						 <input type="hidden" name="pageNum" value="${pc.paging.pageNum}">
						<input type="hidden" name="countPerPage"value="${pc.paging.countPerPage}">
						<input type="hidden" name="keyword" value="${pc.paging.keyword}"> 
						<input type="hidden" name="condition" value="${pc.paging.condition}">


					</div>
				</form>
			</div>
		</div>
		</div>

		<!--쪽지모달-->


		<div class="modal_wrap">


			<div class="modal-contnet">
				<div class="mini-title">작성자님에게 보내는 쪽지</div>
				<textarea class="modal-txtcontent" rows="4" cols=25"></textarea>
				<button class="send-modalBtn">
					<a href="#">보내기</a>
				</button>
				<button class="close-modalBtn">
					<a href="#">닫기</a>
				</button>
			</div>


		</div>



	</section>


	<footer id="footer">
		<%@ include file="../include/footer.jsp"%>
	</footer>
</body>

 

tittle_box에서 jstl로 게시판을 구분해준다. 

이건 헤더에서도 마찬가지로 구분해준다. 

 

대략 요론 페이지가 나온다.

sql문을 만들자!

 

  		<sql id="search">
		<if test="paging.condition == 'board_title'">
			and board_title LIKE '%'||#{paging.keyword}||'%'
		</if>
		<if test="paging.condition == 'board_content'">
			and board_content LIKE '%'||#{paging.keyword}||'%'
		</if>
		<if test="paging.condition == 'board_writer'">
			and board_writer LIKE '%'||#{paging.keyword}||'%'
		</if> 

	</sql>	
    
    <select id="getJBoard" resultType="com.community.shy.board.command.BoardVO" >
		
		select * from
		(
		select rownum as rn , tbl. * from
		(
		SELECT * FROM job_board 
		where board_type = #{board_type}
		<include refid="search" />
		ORDER BY Board_no DESC
		)tbl
		)
		<![CDATA[
		WHERE rn > (#{paging.pageNum ,jdbcType=VARCHAR} - 1) * #{paging.countPerPage,jdbcType=VARCHAR}
		AND rn <= #{paging.pageNum,jdbcType=VARCHAR} * #{paging.countPerPage,jdbcType=VARCHAR}
		]]>
		
	</select>

search라는 이름으로 검색을 할수 있게 해주었다. 

where절에 board_type으로 구분해준다. 

view에서 파라미터 값으로 type을 전달해 줄것이다. 

이떄 sql문 board_type으로 구분을 해준다. 

 

그 뒤 페이징을 통해 처음에 구성해준 countparpage를 통해 몇개의 열이 화면에 보여줄지를 결정하게 된다. 

 

컨트롤러 구성

@Controller
@RequestMapping("/board")
public class BoardController {

	@Autowired
	private IBoardService service;

	
	@GetMapping("/JBoardList")
	public String BoardList(int board_type , PageVO paging ,Model model) {
		System.out.println("리스트 페이지 입니다. ");
		
		System.out.println("검색어: " + paging.getKeyword());
		System.out.println("검색 조건: " + paging.getCondition());
		
		PageCreator pc = new PageCreator();
		System.out.println(paging);
		pc.setPaging(paging);
		pc.setArticleTotalCount(service.getJTotal(paging, board_type));
		
		model.addAttribute("boardList", service.getJBoard(board_type, paging));
		model.addAttribute("type", board_type);
		model.addAttribute("pc", pc);
		System.out.println(pc);
		
		return "/board/JBoardList";
		
				
	}

컨트롤러에서는 board_type과 page에 대한 정보를 받고 model객체로 감싸 view에 뿌려준다. 

 

@Service
public class BoardService implements IBoardService {
	
	@Autowired
	private IBoardMapper mapper; 
	
	@Override
	public List<BoardVO> getJBoard(int board_type, PageVO paging) {
		List<BoardVO> list = new ArrayList<BoardVO>();
		
		Map<String, Object> data = new HashMap<>();
		data.put("board_type", board_type);
		data.put("paging", paging);
		
		return mapper.getJBoard(data);
	}

서비스 구분 2개의 파라미터를 전달을 해주기위해 map으로 포장해준다. 

 

인터페이스 메퍼에서는 map 타입으로 전달 받는다. 

public interface IBoardMapper {
//	게시판 구분 
	List<BoardVO> getJBoard(Map<String, Object> data)

그 후 

이렇게 더미데이터를 몇개 넣어주면

 

대략 요론 페이지가 나온다.

페이징을 통한 여러 게시판이 완성이 된다!

 

https://github.com/MoonSeokHyun/JobJob_community

 

GitHub - MoonSeokHyun/JobJob_community

Contribute to MoonSeokHyun/JobJob_community development by creating an account on GitHub.

github.com

 

반응형
반응형

현재 개발하고 있는 프로젝트임. 

 

나는 게시판쪽이랑 댓글 쪽을 배정받아 작업을 이어나감. 

 

이렇게 5개의 카테고리가 있으며 총 14개의 게시판을 짜야함

이럴 경우에 테이블에서 type을 주어 게시판 분리를 시켜줬음 .

 

그리고 게시판 메인에 게시판 리스트는 

type 1,2를 묶어 보여주고 , 3,4,5,6 이런식으로 묶어서 실시간으로 올라온 글을 보여주게함. 

 

아직 다듬어 지지는 않았지만 게시판임 

하지만 단점이 번호가 1씩 안올라간다는거임 테이블 컬럼을 하나 추가하여 적용했어야하는데 나의 큰 실수임.

 

 

댓글 같은 경우 아직 폼을 만들지 않아 카운터랑 밑에 쓴글만 보이게 함 

나중에 디자인할 예정

 

이외에도 상세보기 수정 등이 있지만 너무 간단하여 나중에 한번에 업데이트할 예정임.

반응형

+ Recent posts