def list(request):
board = Board()
board.user.id = request.POST.get('user.id')
board.tilte = request.POST['title']
board.content = request.POST['content']
return render(request, 'board/list.html')
def insert(request):
if 'authuser' not in request.session:
return HttpResponseRedirect('/board')
board = Board()
board.title = request.POST['title']
board.content = request.POST['content']
board.user = User(**request.session['authuser'])
# 그룹번호 1부터 시작
groupno = int(request.POST['groupno'])
if groupno == 0:
value = Board.objects.aggregate(max_groupno=Max('groupno'))
groupno = 1 if value[
'max_groupno'] is None else value['max_groupno'] + 1
board.groupno = groupno
orderno = 0 if request.POST['groupno'] == '0' else int(
request.POST['orderno'])
Board.objects.filter(groupno=groupno).filter(
orderno__gte=orderno + 1).update(orderno=F('orderno') + 1)
board.orderno = orderno + 1
board.depth = 0 if request.POST['groupno'] == '0' else int(
request.POST['depth']) + 1
board.save()
page = request.POST['page']
kwd = request.POST['kwd']
return HttpResponseRedirect(f'/board/list?page={page}&kwd={kwd}')
def create_board(request, success_url=None):
result = {}
if request.method == 'POST':
data = request.POST
user_id = request.user._id
name = data.get('name')
category = data.get('category')
existedBoard = Board.objects(name=name).count()
if existedBoard :
print 'board is existed!'
result['hasBoard'] = 'board is existed!'
#return render(request,'board/create_board.html',result)
else:
board = Board(user_id = user_id, name = name, category = category
,slug = slugfy(name))
board.save()
success_url = success_url or get_default_redirect(request)
return redirect(success_url)
else:
pass
return render(request,'board/create_board.html',result)
def create_board(request):
if request.POST:
form = BoardForm(request.POST)
if form.is_valid():
new_board = Board()
new_board.save()
welcomePostit = PostIt(text=_("Welcome! Move me! Edit me! Delete me!"),x=120,y=50, board=new_board, width=100,
height=100)
sharePostit = PostIt(text=_("Share this board and work together in realtime!")+ "\n\nhttp://www.boardino.com/"+new_board.hash,
x=200,
y=300,
board=new_board,
width=220,
height=100,
back_color='#FF69B4')
comeBackPostit = PostIt(text=_("Come back to check new features!"),x=550,y=50, board=new_board,
width=150,
height=100,
back_color='#ADFF2F')
welcomePostit.save()
sharePostit.save()
comeBackPostit.save()
return HttpResponseRedirect("/"+new_board.hash)
return HttpResponseRedirect("/")
def test_get_posts_optional_fields(self):
"""Get posts that does have every field"""
b = Board(title='hi', description='hello')
b.save()
posts = [
Post(associated_board=b, message='hi', created_at=timezone.now()),
Post(associated_board=b,
name='shari',
message='cool',
created_at=timezone.now() - timezone.timedelta(1)),
Post(
associated_board=b,
name='joseph',
photo=Image(name='i', photo=bytearray('b', 'utf-8')).save(),
created_at=timezone.now() - timezone.timedelta(2),
),
]
exp = []
for p in posts:
exp.append(get_post_dict(p))
p.save()
res = self.client.get(
reverse('board:posts-get'),
{
'board': str(b.uuid),
'index': '0',
'amount': '10',
},
HTTP_ACCEPT='application/json',
)
self.assertEqual(res.json(), exp)
def reply(request, id=0):
# 로그인 체크
if check_authuser(request) is None:
return HttpResponseRedirect('/user/loginform')
else:
if request.method == 'GET':
return render(request, 'board/write.html')
elif request.method == 'POST':
board = Board.objects.get(id=id)
# query set 예제
# groupno = 1이고 orderno >=1 의
# 게시물의 order_no를 1씩 증가
# __gt, __lt, __gte, __lte
reply_board = Board()
reply_board.title = request.POST['title']
reply_board.content = request.POST['content']
reply_board.user = User.objects.get(id=request.session['authuser']['id'])
reply_board.groupno = board.groupno
# value = Board.objects.filter(groupno=board.groupno).filter(depth=board.depth+1).aggregate(max_orderno=Max('orderno'))
# max_orderno = 0 if value["max_orderno"] is None else value["max_orderno"]
reply_board.orderno = board.orderno + 1
reply_board.depth = board.depth + 1
reply_board.save()
# Board.objects.filter(groupno=board.groupno).filter(orderno=board.orderno).update(depth=F('depth') + 1)
return HttpResponseRedirect('/board/1')
def insert(request):
fname = ""
fsize = 0
if "file" in request.FILES:
file = request.FILES["file"]
fname = file.name
fsize = file.size
fp = open("%s%s" % (UPLOAD_DIR, fname), "wb")
for chunk in file.chunks():
fp.write(chunk)
fp.close()
dto = Board(writer=request.POST["writer"], title=request.POST["title"],
content=request.POST["content"], filename=fname, filesize=fsize,
video_url=request.POST["video_url"],
section_school=request.POST["section_school"],
section_subject=request.POST["section_subject"],
section_semester=request.POST["section_semester"],
grade=request.POST["grade"],
th_high=request.POST["th_high"],
th_medium=request.POST["th_medium"],
th_default=request.POST["th_default"]
)
dto.save()
return redirect("/")
def insert(request):
# 파일 업로드 작업
fname = ""
fsize = 0
# 업로드된 파일이 있으면
if "file" in request.FILES:
# <input type="file">태그의 name
file = request.FILES["file"]
# 첨부파일의 이름
fname = file._name
# wb : 이진파일 쓰기 모드
fp = open("%s%s" % (UPLOAD_DIR, fname), "wb")
# 파일을 몇개의 뭉치로 나눠서 저장
for chunk in file.chunks():
fp.write(chunk)
fp.close()
# 첨부파일의 크기(업로드 완료 후 계산)
fsize = os.path.getsize(UPLOAD_DIR + fname)
vo = Board(writer=request.POST["writer"],
title=request.POST["title"],
content=request.POST["content"],
filename=fname,
filesize=fsize)
# insert query가 실행됨
vo.save()
# django의 콘솔에 출력됨
print(vo)
# 목록으로 이동
return redirect("/")
def reply(request):
authuser = request.session.get('authuser')
if authuser is None:
# 유저가 아닌 접근이므로. 비정상 접근이거나 세션 해제된 상태.
return HttpResponseRedirect('/')
title = request.POST.get('title', '')
contents = request.POST.get('contents', '')
g_no = request.POST.get('g_no', 0)
o_no = request.POST.get('o_no', 0)
depth = request.POST.get('depth', 0)
user = User.objects.get(id=authuser['id'])
# 저장 처리
board = Board()
board.title = title
board.contents = contents
board.user = user
board.g_no = int(g_no)
board.o_no = int(o_no) + 1
board.depth = int(depth) + 1
board.save()
# ret = Board.reply(data)
# if ret != 1:
# return HttpResponse('오류 발생')
return HttpResponseRedirect('/board/')
def write_reply(request, parent_id):
authuser = check_login_auth(request)
if authuser is None:
return HttpResponseRedirect('/user/loginform')
board = Board()
parent = Board.objects.get(id=parent_id)
groupno = parent.groupno
orderno = parent.orderno + 1
depth = parent.depth + 1
results = Board.objects.filter(groupno=groupno).filter(
orderno__gte=orderno).update(orderno=F('orderno') + 1)
title = request.POST['title']
content = request.POST['content']
userid = request.session['authuser']['id']
board.title = title
board.content = content
board.user_id = userid
board.groupno = groupno
board.orderno = orderno
board.depth = depth
board.save()
return HttpResponseRedirect('/board')
def add(request):
add_up = Board(pwd=request.POST['pwd'],
writer=request.POST['writer'],
subject=request.POST['subject'],
content=request.POST['content'])
add_up.save()
return redirect('/board')
def write_board(request):
write_data = Board (writer = request.POST.get('_writer', False),
title = request.POST.get('_title', False),
board_contents = request.POST.get('_board_contents', False),
board_date = timezone.now()
)
write_data.save()
url = '/board/'
return HttpResponseRedirect(url)
def create(self, request):
try:
board = Board(name=request.data['name'], owner=request.user)
board.save()
board.members.add(request.user)
board.moderators.add(request.user)
except Exception as e:
if hasattr(e, 'message'):
return Response({"success": False, "error": e.message})
else:
return Response({"success": False, "error": str(e)})
return Response(BoardSerializer(board).data)
def test_board_post_connections(self):
"""Make sure that posts to a board are properly associated and posts can be found."""
i1 = Image(name="1", photo=bytearray("1", "utf-8"))
i2 = Image(name="2", photo=bytearray("2", "utf-8"))
i3 = Image(name="3", photo=bytearray("3", "utf-8"))
i1.save()
i2.save()
i3.save()
b1 = Board(title="foo", description="bar", bg=i1)
b2 = Board(title="foo2", description="bar", bg=i2)
b1.save()
b2.save()
p1 = Post(associated_board=b1, name="a", message="b")
p2 = Post(associated_board=b1, name="a", photo=i3)
p3 = Post(associated_board=b2, name="a", message="b")
p4 = Post(associated_board=b1, name="a", message="b")
p1.save()
p2.save()
p3.save()
p4.save()
self.assertQuerysetEqual(b1.post_set.all(), [p1, p2, p4],
ordered=False)
self.assertQuerysetEqual(b2.post_set.all(), [p3], ordered=False)
def insert(request):
fname=''
fsize =0
if 'file' in request.FILES:
file = request.FILES['file']
fname = file._name
with open('%s%s' % (UPLOAD_DIR,fname),'wb') as fp:
for chunck in file.chuncks():
fp.write(chunck)
fsize = os.path.getsize(UPLOAD_DIR + fname)
row = Board(writer=request.POST['writer'], title=request.POST['title'], content = request.POST['content'],
filename=fname, filesize=fsize)
row.save()
return redirect('/')
def write(request):
authuser = request.session.get('authuser')
if authuser is None:
# 유저가 아닌 접근이므로. 비정상 접근이거나 세션 해제된 상태.
return HttpResponseRedirect('/')
title = request.POST.get('title', '')
contents = request.POST.get('contents', '')
user = User.objects.get(id=authuser['id'])
max_gno = Board.objects.aggregate(g_no=Max('g_no'))['g_no']
if max_gno is None or max_gno == '':
max_gno = 0
# 저장 처리
board = Board()
board.title = title
board.contents = contents
board.user = user
board.g_no = int(max_gno) + 1
board.save()
# board = Board(title=title, contents=contents, user=user)
# board.save()
# ret = Board.insert(data)
# if ret != 1:
# return HttpResponse('오류 발생')
return HttpResponseRedirect('/board/')
def board_edit(request, board_id=None):
user = request.user.pk
user_type = request.user.profile.type
if board_id:
board = get_object_or_404(Board, pk=board_id)
else:
board = Board()
if request.method == "POST":
# POST 된 request 데이터를 가지고 Form 생성
form = BoardForm(request.POST, instance=board)
if form.is_valid():
board = form.save(commit=False)
board.board_id = Board(board_id)
board.writer = User(user)
if not board_id:
board.category = user_type
board.save()
# request 없이 페이지 이동만 한다.
return redirect('board:list')
else:
# book instance에서 Form 생성
form = BoardForm(instance=board)
# 사용자의 request를 가지고 이동한다.
return render(request, 'board/board_edit.html',
dict(form=form, board=board))
def test_post_creation_combinations(self):
"""Make sure that creating posts in different combinations doesn't break anything."""
i1 = Image(name="1", photo=bytearray("1", "utf-8"), uuid=uuid.uuid4())
i2 = Image(name="2", photo=bytearray("2", "utf-8"))
i3 = Image(name="3", photo=bytearray("3", "utf-8"))
i4 = Image(name="2", photo=bytearray("2", "utf-8"))
i5 = Image(name="3", photo=bytearray("3", "utf-8"))
i1.save()
i2.save()
i3.save()
i4.save()
i5.save()
b1 = Board(title="foo", description="bar", bg=i1)
b2 = Board(title="green eggs", description="and ham")
b1.save()
b2.save()
# just make sure that none of these throw an exception when creating
p1 = Post(associated_board=b1, message="post1")
p2 = Post(associated_board=b1, name="author2", photo=i2)
p3 = Post(associated_board=b1, photo=i3)
p4 = Post(associated_board=b1,
name="author4",
message="post4",
photo=i4)
p5 = Post(associated_board=b1, message="post5", photo=i5)
p1.save()
p2.save()
p3.save()
p4.save()
p5.save()
def test_board_post_image_connections(self):
"""Make sure that boards and posts and their connections to an image does not throw errors."""
b1 = Board(title="board1", description="bar")
b1.save()
i2 = Image(name="foo", photo=bytearray("bar", "utf-8"))
i3 = Image(name="ham", photo=bytearray("sam", "utf-8"))
i2.save()
i3.save()
b2 = Board(title="board2", description="foo", bg=i2)
b2.save()
self.assertIs(b2.bg, i2)
self.assertIs(i2.board, b2)
p1 = Post(associated_board=b2, name="p1", message="m1")
p2 = Post(associated_board=b2,
name="p1",
message="m1",
photo=Image(name="spam", photo=bytearray("eggs",
"utf-8")).save())
p3 = Post(associated_board=b2, name="p1", message="m1", photo=i3)
p1.save()
p2.save()
p3.save()
self.assertIs(p3.photo, i3)
self.assertIs(i3.post, p3)
self.assertIs(p2.photo.name, "spam")
def add(request):
board_txt = Board()
board_txt.title = request.POST['title']
board_txt.content = request.POST['content']
board_txt.user_id = request.session['authuser']['id']
board_txt.hit = 0
board_txt.name = request.session['authuser']['name']
board_txt.save()
return HttpResponseRedirect('/board')
def write(request):
board = Board()
board.title = request.POST['title']
board.content = request.POST['content']
board.user = User.objects.get(id=request.session['authuser']['id'])
board.groupno = counter_max()
board.save()
return HttpResponseRedirect('/board')
def new_board(request):
form = BoardForm()
if request.method == 'POST':
form = BoardForm(request.POST)
if form.is_valid():
title = form.cleaned_data['title']
desc = form.cleaned_data['description']
board = Board(title=title, desc=desc)
board.save()
return HttpResponseRedirect('/board')
context = {
'form': form
}
return render(request, 'board_new.html', context)
def reply(request, id=0):
original = Board.objects.get(id=id)
board = Board()
board.title = request.POST['title']
board.content = request.POST['content']
board.groupno = original.groupno
board.orderno = original.orderno
board.depth = original.depth + 1
board.user_id = request.session['authuser']['id']
Board.objects.filter(groupno=original.groupno).filter(
orderno__gte=original.orderno).update(orderno=F('orderno') + 1)
board.save()
return HttpResponseRedirect('/board')
def settings(request):
if request.method == 'POST':
form = PlayersChoiceForm(request.POST)
if form.is_valid():
p1 = form.cleaned_data.get('p1')
p2 = form.cleaned_data.get('p2')
if p1 == p2:
messages.error(request,
'You cannot play with both the same player')
return redirect('/board/game/settings')
else:
if (p1.isAI):
p1.init_ai(1)
if (p2.isAI):
p2.init_ai(2)
board_set = Board.objects.filter(name="game")
if len(board_set) < 1:
board = Board.create_and_init_board("game", 4)
board.save()
else:
board = board_set[0]
board.p1 = p1
board.p2 = p2
board.save()
return redirect('game')
else:
form = PlayersChoiceForm()
return render(request, 'board/settings.html', {'form': form})
def update(request):
id = request.POST['idx']
row_src= Board.objects.get(idx=id)
fname = row_src.filename
fsize = row_src.filesize
if 'file' in request.FILES:
file = request.FILES['file']
fname = file._name
with open('%s%s' %(UPLOAD_DIR, fname),'wb')as fp:
for chunck in file.chuncks():
fp.write(chunck)
fsize = os.path.getsize(UPLOAD_DIR+fname)
row_new= Board(idx=id, writer=request.POST['writer'], title=request.POST['title'], content=request.POST['content'],
filename=fname, filesize=fsize)
row_new.save()
return redirect('/')
def write_create(request):
if request.method == 'POST' and request.session.get('user', False):
title = request.POST['title']
author = get_object_or_404(CustomUser, username=request.session['user'])
content = request.POST['content']
write = Board(
title = title,
author = author,
content = content,
)
write.save()
return redirect('write_read')
else:
return render(request, 'write/create.html')
def game(request):
board_set = Board.objects.filter(name="game")
if len(board_set) < 1:
last_board = Board.objects.latest('date')
board = Board.create_and_init_board("game", 4)
board.save()
messages.success(request, last_board.get_winner_name())
return redirect('/board/home')
else:
board = board_set[0]
if board.p1 and board.p2:
currentPlayerId = board.nbTurns % 2 + 1
if currentPlayerId == 1:
currentPlayer = board.p1
isCurrentPlayerAI = board.p1.isAI
else:
currentPlayer = board.p2
isCurrentPlayerAI = board.p2.isAI
if isCurrentPlayerAI:
best_ai_move = currentPlayer.ai.get_move(board)
board.move(currentPlayerId, str(best_ai_move))
time.sleep(0.5)
print(f"Player 1 : {board.p1} - Player 2 : {board.p2}")
return render(request, 'board/test.html', {
'grid': board.print_board(),
'nbTurns': board.nbTurns,
'board': board
})
def insert(request):
fname = ""
fsize = 0
if "file" in request.FILES: #d\request.FILES에 file이 있는가 - 파일넘어왓는가
file=request.FILES["file"]
fname = file.name
fsize = file.size
fp=open("%s%s" % (UPLOAD_DIR, fname), "wb")
for chunk in file.chunks():
fp.write(chunk)
fp.close()
dto = Board( writer=request.POST["writer"],title=request.POST["title"], content=request.POST["content"], filename=fname,filesize=fsize )
dto.save()
print(dto)
return redirect("list/")
def write_comment(request):
board_id = request.GET.get('board_id', )
input_comment = request.GET.get('comment', )
user = request.user.pk
comment = Comment()
comment.board_id = Board(board_id)
comment.writer = User(user)
comment.content = input_comment
comment.status = 'y'
try:
comment.save()
result = json.dumps([
{'result': 'seccess'}
])
except Exception as e:
print(e)
result = json.dumps([
{'result':'fail'}
])
return HttpResponse(result, content_type="application/json:charset=UTF-8")
def clone(request, board_hash):
board = get_object_or_404(Board, hash=board_hash)
new_board = Board()
new_board.save()
for postit in board.postit_set.all():
postit_clone = postit.clone()
postit_clone.board = new_board
postit_clone.save()
for line in board.line_set.all():
line_clone = line.clone()
line_clone.board = new_board
line_clone.save()
return HttpResponseRedirect("/"+new_board.hash)
def upload_pin(request):
#user = get_user
data = {}
if request.method == 'POST':
form = forms.PinUploadForm(request.POST,request.FILES)
if form.is_valid():
print 'form is valid'
img = request.FILES['img']
print img,type(img)
img_url = save_img(img)
print img_url
pin = Pin()
pin.user_id = request.user._id
pin.img_url = img_url
pin.desc = form.cleaned_data['desc']
pin.board_id = form.cleaned_data['board_id']
pin.sync = form.cleaned_data['sync']
pin.save()
return redirect('/success/url/')
else:
print 'form not valid'
data['form'] = form
else:
form = forms.PinUploadForm()
userBoards = Board.objects(user_id=request.user._id)
print userBoards
for board in userBoards:
print board.name
data['form'] = form
return render(request,'pins/upload_pin.html',data)
def AdminWritePostView(request):
if request.user.is_superuser:
if request.method == 'POST':
form = AdminPostForm(request.POST)
if form.is_valid():
post = Board(user=request.user,
category=form.cleaned_data['category'],
title=form.cleaned_data['title'],
content=form.cleaned_data['content'])
post.save()
return HttpResponseRedirect('/admin/add-category/')
else:
form = AdminPostForm(initial=request.GET)
return render(request, 'board/write_post.html', dict(form=form))
else:
form = PostForm(initial=request.GET)
return render(request, 'board/write_post.html', dict(form=form))
def create_lecture_boards(self):
lecture_suites = LectureSuite.objects.all()
for lecture_suite in lecture_suites:
if len(Board.objects.filter(
display_name__exact=lecture_suite.name)) > 0:
logger.info(f'{lecture_suite.name}에 대한 게시판이 존재합니다.')
else:
logger.info(
f'{lecture_suite.name} LectureSuite에 대한 Board를 생성합니다.')
board = Board(
name=lecture_suite.name,
display_name=lecture_suite.name,
description=f'{lecture_suite.name}에 대한 게시판입니다.',
category='lecture_suite',
related_lecture_suite=lecture_suite,
)
board.save()
def write(request):
board = Board()
board.title = request.POST['title']
board.content = request.POST['content']
board.name = request.session['authuser']['name']
board.user_id = request.session['authuser']['id']
board.save()
return HttpResponseRedirect('/board')
def setUp(self):
self.USER_USERNAME = "******"
self.USER_EMAIL = "*****@*****.**"
self.USER_PASSWORD = "******"
self.GAME = 6667
self.PLAYER_ID = 6677
# Create user
user_data = {
"username": self.USER_USERNAME,
"email": self.USER_EMAIL,
"password": self.USER_PASSWORD,
}
user = User._default_manager.create_user(**user_data)
user.save()
board_data = {
'name': 'boardcito',
'owner': user
}
board = Board(**board_data)
board.save()
room_data = {
'name': 'roomcito',
'board': board,
'game_has_started': False,
'owner': user,
}
room = Room(**room_data)
room.save()
game = Game(room=room)
game.save()
self.GAME = game.id
# Create Player
player_data = {
'id': self.PLAYER_ID,
'user': user,
'game': game,
'colour': 'colorcito',
}
player = Player.objects.create(**player_data)
player.save()
def board_write(request):
if not request.session.get('user'):
return redirect('/scum/login/')
if request.method == 'POST':
form = BoardForm(request.POST)
if form.is_valid():
user_id = request.session.get('user')
scumuser = scumUser.objects.get(pk=user_id)
tags = form.cleaned_data['tags'].split(',')
board = Board()
board.title = form.cleaned_data['title']
board.contents = form.cleaned_data['contents']
board.writer = scumuser
board.save()
for tag in tags:
if not tag:
continue
_tag, _= Tag.objects.get_or_create(name=tag)
board.tags.add(_tag)
return redirect('/board/list/')
else:
form = BoardForm
return render(request, 'board_write.html', {'form': form})
def update(request):
print("**")
# 글번호
# id = request.POST["idx"] # 이건 에러뜨고 아래꺼는 ㄱㅊ...
id = request.POST.get('idx', False)
# select * from board_board where idx=id
dto_src = Board.objects.get(idx=id)
dto_src.save()
# 수정시 조회수, 다운로드 수 날라가는거 방지
hitnum = dto_src.hit
downnum = dto_src.down
fname = dto_src.filename # 기존 첨부파일 이름
fsize = dto_src.filesize # 기존 첨부파일 크기
if "file" in request.FILES: # 새로운 첨부파일이 있으면
file = request.FILES["file"]
fname = file.name # 새로운 첨부파일 이름
fsize = file.size
fp = open("%s%s" % (UPLOAD_DIR, fname), "wb")
for chunk in file.chunks():
fp.write(chunk) # 파일 저장
fp.close()
# 첨부파일 크기 ( 업로드 완료 후 계산
fsize = os.path.getsize(UPLOAD_DIR + fname)
# 수정 후 board의 내용
dto_new = Board(idx=id, writer=request.POST["writer"], title=request.POST["title"],
content=request.POST["content"], filename=fname, filesize=fsize, hit=hitnum, down=downnum,
video_url=request.POST["video_url"],
section_school=request.POST["section_school"],
section_subject=request.POST["section_subject"],
section_semester=request.POST["section_semester"],
grade=request.POST["grade"],
th_high=request.POST["th_high"],
th_medium=request.POST["th_medium"],
th_default=request.POST["th_default"]
)
dto_new.save() # update query 호출
return redirect("/") # 시작페이지로 이ddong
def create_board(request):
new_board = Board()
new_board.save()
welcomePostit = PostIt(text="Welcome! Move me! Edit me! Delete me!",x=120,y=50, board=new_board, width=100,
height=100)
sharePostit = PostIt(text="Share this board and work together in realtime!\n\nhttp://www.boardino.com/"+str(new_board.id),
x=200,
y=300,
board=new_board,
width=220,
height=100,
back_color='#FF69B4')
comeBackPostit = PostIt(text="Come back to check new features!",x=550,y=50, board=new_board,
width=150,
height=100,
back_color='#ADFF2F')
welcomePostit.save()
sharePostit.save()
comeBackPostit.save()
return HttpResponseRedirect("/"+str(new_board.id))
def write(request):
try:
board = Board()
board.title = request.POST['title']
board.content = request.POST['content']
# 아래부분은 수정해야 할 사항으로###############################################################################
# 현재는 이메일과 패스워드로 비교하여 쿼리셋의 첫번째 user를 선택하도록 정하고 테스트 하였지만.
# 실제로는 email을 primary 키로, 혹은 같은 이메일은 등록이 불가하도록 정의하는 로직이 필요하며,
# 이는 user 객체의 VO 를 재정의 하던지, 유저 등록 시 action 을 재정의 하던지 하여 해결하도록 할 것!
board.user = (User.objects.filter(email=request.session.get('authuser')['email']).filter(
password=request.session.get('authuser')['password']))[0]
################################################################################################################
board.save()
return HttpResponseRedirect('/board')
except DataError:
return render(request, 'board/write.html', {'posts': board, 'data_error':True })
def test_board_list_with_staff_user(self):
# create a private board for user2
self.privateBoard2 = Board(
title='private board2',
description='user2 private board for tests',
policy=0,
user = self.user2)
self.privateBoard2.save()
# add a staff user
self.user2.is_staff = True
self.user2.save()
# login with user
login(self, self.user)
response = self.client.get('/toto/')
self.assertEqual(response.status_code, 200)
# assert we have public boards
self.assertEqual(len(response.context['boards']), 1)
self.assertEqual(response.context['boards'][0].title, 'user2 board')
# assert we have private boards
self.assertEqual(len(response.context['private_boards']), 1)
self.assertEqual(response.context['private_boards'][0].title,
'private board2')
class BoardListTest(TestCase):
"""Board app tests."""
def setUp(self):
# create users
create_test_users(self)
# create boards
create_test_boards(self)
# create private boards
create_test_private_boards(self)
# start client
self.client = Client()
def test_urls(self):
urls = [
{
'url': '/flr/',
'status': 200,
'template': 'board/board_list.html',
},
# unknown user should return 404
{
'url': '/tom/',
'status': 404,
'template': '404.html',
},
]
test_urls(self, urls)
def test_board_list_with_standard_user(self):
# login with user2
login(self, self.user2)
response = self.client.get('/flr/')
self.assertEqual(response.status_code, 200)
# assert we have public boards
self.assertEqual(len(response.context['boards']), 1)
self.assertEqual(response.context['boards'][0].title, 'user board')
# assert we don't have private boards
self.assertEqual(hasattr(response.context, 'private_boards'), False)
def test_board_list_with_owner_user(self):
# login with user
login(self, self.user)
response = self.client.get('/flr/')
self.assertEqual(response.status_code, 200)
# assert we have public boards
self.assertEqual(len(response.context['boards']), 1)
self.assertEqual(response.context['boards'][0].title, 'user board')
# assert we have private boards
self.assertEqual(len(response.context['private_boards']), 1)
self.assertEqual(response.context['private_boards'][0].title,
'private board')
def test_board_list_with_staff_user(self):
# create a private board for user2
self.privateBoard2 = Board(
title='private board2',
description='user2 private board for tests',
policy=0,
user = self.user2)
self.privateBoard2.save()
# add a staff user
self.user2.is_staff = True
self.user2.save()
# login with user
login(self, self.user)
response = self.client.get('/toto/')
self.assertEqual(response.status_code, 200)
# assert we have public boards
self.assertEqual(len(response.context['boards']), 1)
self.assertEqual(response.context['boards'][0].title, 'user2 board')
# assert we have private boards
self.assertEqual(len(response.context['private_boards']), 1)
self.assertEqual(response.context['private_boards'][0].title,
'private board2')
def test_board_search(self):
response = self.client.get('/board/search/?q=user')
self.assertEqual(response.status_code, 200)
self.assertEqual(response.templates[0].name, 'board/board_search.html')
self.assertEqual(len(response.context['page'].object_list), 1)
# quick test of pagination
response = self.client.get('/board/search/?q=user&page=1')
self.assertEqual(response.status_code, 200)
