def board_write(request):
if request.method == "POST":
if not request.body is None:
if User.objects.filter(user = request.POST['user']).exists() :
d = timezone.localtime(timezone.now())
board = Board(user = User.objects.get(user = request.POST['user']),
title = request.POST['title'],
content = request.POST['content'],
cost = request.POST['cost'],
item = request.POST['item'],
date = d.strftime('%Y-%m-%d')
)
board.save()
if not request.FILES.getlist('image') is None:
for f in request.FILES.getlist('image'):
boardImage = BoardImage(board = board,
image = f
)
boardImage.save()
return JSONResponse('')
else :
return HttpResponse(status=400)
else :
return HttpResponse(status=400)
else :
return HttpResponse(status=400)
def generate_board(game_id):
boggle_board = Board.query.filter_by(id=game_id).first()
if not boggle_board:
board_dice = random.sample(Config.DICE, len(Config.DICE))
board = []
for _ in range(4):
board.append([random.choice(board_dice.pop()) for __ in range(4)])
boggle_board = Board(board)
db.session.add(boggle_board)
db.session.commit()
board = boggle_board.generate_board()
start = time.time()
words = solver.generate_words(boggle_board)
time_taken = f"{(time.time() - start) * 1000:.4f}"
return {
"game_id": boggle_board.id,
"board": board,
"words": words,
"time_taken": time_taken
}
def post_board():
form = BoardForm() # need to build a form
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
new_board = Board()
form.populate_obj(new_board)
db.session.add(new_board)
db.session.commit()
return new_board.to_dict()
return {"errors": "Error occured"}
def create_board():
data = request.json
data['description'] = " "
new_board = Board(title=data['title'],
color=data['color'],
description=data['description'],
user_id=data['userId'])
db.session.add(new_board)
db.session.commit()
format_board = new_board.to_dict()
return {"board": format_board}
def add_board(request):
print('add_board_test1')
#게시물 작성 후 리다이렉트
print(request.POST.get("board_title"))
print(request.POST.get("board_content"))
board = Board(
board_title=request.POST.get("board_title"),
board_content=request.POST.get("board_content"),
)
# db에 반영
board.save()
# 게시물 목록으로 리다이렉트
return redirect("/get_board_list")
def bulletin_board():
admin_id = g.admin_id # 获取管理员的id
admin_name = session.get("username") # 获取管理员的名字
ip_addr = request.remote_addr # 获取管理员登录的ip
req_dict = request.get_json()
title = req_dict.get("title")
content = req_dict.get("content")
# 校验参数
# 参数完整的校验
if not all([title, content, ip_addr]):
return jsonify(re_code=400, msg="参数不完整")
# 将数据保存
board = Board(title=title, content=content, admin_id=admin_id)
try:
detail = "管理员:%s --> id:%s ; 新发送了公告 <%s> " % (admin_name, admin_id,
title)
admin_operate_log = AdminOperateLog(admin_id=admin_id,
ip=ip_addr,
detail=detail)
db.session.add(board)
db.session.add(admin_operate_log)
db.session.commit()
return jsonify(re_code=200, msg="保存数据成功")
except:
db.session.rollback()
return jsonify(re_code=400, msg="保存数据失败")
def decorated_view(*args, **kwargs):
board_id = kwargs['board_id']
if not Board.objects(id=board_id, is_deleted=False):
return jsonify(message='없는 게시판입니다.'), 404
return f(*args, **kwargs)
def bulletin_board():
req_data = request.get_json()
admin_id = g.admin_id
title = req_data.get("title")
content = req_data.get("content")
if not all([admin_id, title, content]):
return jsonify(msg="参数不完整", code=4000), 400
# 存的是 公告
board = Board(title=title, content=content, admin_id=admin_id)
db.session.add(board)
# 存操作日志
ip = request.remote_addr
detail = "添加了公告：" + title
aol = AdminOperateLog(admin_id=admin_id, ip=ip, detail=detail)
db.session.add(aol)
try:
db.session.commit()
except Exception as e:
print(e)
db.session.rollback()
return jsonify(msg="提交不成功", code=4001), 400
return jsonify(msg="提交成功", code=200), 200
def bulletin_board():
admin_id = g.admin_id # 获取管理员的id
ip_addr = request.remote_addr # 获取管理员登录的ip
req_dict = request.get_json()
title = req_dict.get("title")
content = req_dict.get("content")
# 校验参数
# 参数完整的校验
if not all([title, content, ip_addr]):
return jsonify(code=400, msg="参数不完整")
# 将数据保存
board = Board(title=title, content=content, admin_id=admin_id)
try:
detail = "发送了新公告: %s " % title
admin_operate_log = AdminOperateLog(admin_id=admin_id, ip=ip_addr, detail=detail)
db.session.add(board)
db.session.add(admin_operate_log)
db.session.commit()
return jsonify(code=200, msg="保存数据成功")
except Exception as e:
print(e)
db.session.rollback()
return jsonify(code=400, msg="保存数据失败")
def cast_vote(search_name):
if not request.json or (not ('voter' in request.json)
and not ('ballot' in request.json)
and not ('election_id' in request.json)):
return bad_request('Не все заголовки')
# Проверка существования такого голосования
election = Election.query.filter_by(search_name=search_name).first()
if election is None:
return not_found('Такого голосования нет')
# Проверка доступа
voter = Voter.query.filter_by(election_id=election.election_id).filter_by(
e_mail=request.json['voter']['e_mail']).first()
if not voter:
return unauthorized('Неверный e-mail адрес')
if not voter.password == request.json['voter']['password']:
return unauthorized('Неверный пароль')
# Проверка, существует ли уже бюллетень от этого пользователя
old_ballot = Board.query.filter_by(
election_id=election.election_id).filter_by(
voter_id=voter.voter_id).first()
if not (old_ballot is None):
db.session.delete(old_ballot)
# Добавление бюллетеня
ballot = Board(election_id=election.election_id,
voter_id=voter.voter_id,
voter_identifier=voter.voter_identifier,
ballot_dict=request.json['ballot'])
db.session.add(ballot)
db.session.commit()
return make_response(jsonify({'status': 'OK'}), 200)
def create_board(name):
board = session.query(Board).filter_by(name=name).first()
if not board:
if 'session' in web_session:
user_id = redisSession.open_session(web_session['session'])
if user_id:
board = Board(
name = name,
master = user_id
)
save(board)
response = {
'status': 'success',
'message': 'Create board successfully'
}
return response, 201
else:
response = {
'status': 'fail',
'message': 'Permission denied'
}
return response, 403
else:
response = {
'status': 'fail',
'message': 'Login required'
}
return response, 403
else:
response = {
'status': 'fail',
'message': 'Already existed board'
}
return response, 409
def test_board(app, db, dummy_user):
board = Board(
name='My board',
owner_id=dummy_user.id
)
assert board.name == 'My board'
assert board.owner_id == dummy_user.id
def get_category(self):
"""
게시판 카테고리 조회 API
:return: 게시판 카테고리
"""
boards = Board.objects(is_deleted=False)
board_category = BoardCategorySchema(many=True).dump(boards)
return {'category': board_category}, 200
def add_board():
form = BoardAddForm()
if form.validate_on_submit():
b = Board(ref=form.ref.data, description=form.description.data)
db.session.add(b)
db.session.commit()
return redirect(url_for('main.board_b', board=b.ref))
return render_template('add_board.html', form=form)
def create_board():
"""Create the board needed for the foreign key constraint."""
db.session.add(
Board(
name='board_name',
url=f"https://trello.com/b/{default_board_id}",
trello_board_id=default_board_id
)
)
def seed_boards(data):
for exp in data:
try:
for b in data[exp].get("boards"):
board = Board.query.get(b) or Board()
board.id = b
board.expansion_id = exp
board.is_thematic = data[exp]["boards"][b].get("thematic")
db.session.add(board)
except TypeError:
pass
def post(self):
data = parser.parse_args()
name = data['name']
owner_id = data['owner_id']
try:
new_board = BoardModel(
name=name,
owner_id=uuid.UUID(owner_id)
)
new_board.save()
return {
'board': marshal(new_board, permitted)
}, HTTPStatus.CREATED
except Exception as error:
return {
'message': str(error)
}, HTTPStatus.INTERNAL_SERVER_ERROR
def create_board():
form = CreateThreadForm()
if form.validate_on_submit():
bn = Board(title=form.name.data, body=form.description.data)
db.session.add(bn)
db.session.commit()
flash(_('Your board has been created.'))
return redirect(url_for('main.index'))
return render_template('create_board.html', form=form)
def test_board_model(session):
board = Board(
name='Memory Card Game',
global_best=20
)
session.add(board)
session.commit()
getboard = Board.query.filter_by(name=board.name).first()
assert getboard.name is board.name
def boards():
currentboards = current_user.created_boards
form = BoardForm()
if form.validate_on_submit():
board = Board(name=form.name.data, creator=current_user)
db.session.add(board)
db.session.commit()
flash(_('Your board has been created'))
return redirect(url_for('main.boards'))
return render_template('boards.html', boards=currentboards, form=form )
def newboard():
form = NewBoardForm()
if form.validate_on_submit():
board = Board(name=form.name.data)
current_user.boards.append(board)
db.session.add(board)
db.session.commit()
flash('New board created!')
return redirect(url_for('index'))
return render_template('newboard.html',
title='Create new board',
form=form)
def new_board():
board = request.get_json()
error = validator('board', board)
if error:
return jsonify(error)
add_board = Board(board_name=board.get("board_name"),
user_id=session["user_id"])
db.session.add(add_board)
db.session.commit()
return redirect("/")
def delete(self, board_id):
"""
게시판 삭제 API
:param board_id: 게시판 objectId
:return: message
"""
if not g.master_role:
return jsonify(message='권한이 없는 사용자입니다.'), 403
board = Board.objects(id=board_id, is_deleted=False).get()
board.update(is_deleted=True)
return jsonify(message='삭제되었습니다.'), 200
def board_write(request):
if request.method == "POST":
if not request.body is None:
if User.objects.filter(user=request.POST['user']).exists():
d = timezone.localtime(timezone.now())
board = Board(user=User.objects.get(user=request.POST['user']),
title=request.POST['title'],
content=request.POST['content'],
cost=request.POST['cost'],
item=request.POST['item'],
date=d.strftime('%Y-%m-%d'))
board.save()
if not request.FILES.getlist('image') is None:
for f in request.FILES.getlist('image'):
boardImage = BoardImage(board=board, image=f)
boardImage.save()
return JSONResponse('')
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
else:
return HttpResponse(status=400)
def post(data):
board = Board()
board.title = data.get('title')
board.description = data.get('description')
board.save()
access = BoardAccessMatrix()
access.board = board
access.user = User.objects.get(email=data.get('email'))
access.level = 'admin'
access.save()
return board
def board_submit():
data = request.get_json()
name = data["name"]
sounds = data["sounds"]
board_id = data["board_id"]
if board_id == -1:
# neues board erstellen
if not name:
flash('Kein Name.', 'danger')
return "/admin/boards"
board = Board.query.filter_by(name=name).first()
if board:
flash('Dieser Name existiert bereits.', 'danger')
return "/admin/boards"
# add to database
new_board = Board(name=name)
db.session.add(new_board)
db.session.commit()
for s in sounds:
sound = Sound.query.filter_by(id=s).first()
if sound:
new_board.sounds.append(sound)
db.session.commit()
flash('Board erstellt.', 'success')
else:
# board bearbeiten
board = Board.query.filter_by(id=board_id).first()
if name:
board.name = name
db.session.commit()
for s in board.sounds:
if not s.id in sounds:
sound = Sound.query.filter_by(id=s.id).first()
board.sounds.remove(sound)
db.session.commit()
for s_id in sounds:
sound = Sound.query.filter_by(id=s_id).first()
if not sound in board.sounds:
board.sounds.append(sound)
db.session.commit()
flash('Board bearbeitet.', 'success')
return "/admin/boards"
def test_suite(self, num_runs=None, do_duplicate_analysis=False):
"""
Test suite to drill down and time individual runs of the algorithm to get a closer look at the core algorithm
excluding overhead. Also performs some basic analysis of how run times are distributed
:param num_runs: number of test runs to do
:param do_duplicate_analysis:
:return:
"""
print("\nStarting individual test suite...")
if not num_runs:
num_runs = self.runs
run_times = []
interesting_dice = []
for run in range(num_runs):
start = time.time()
board = Board()
word_list = self.solver.generate_words(board,
do_duplicate_analysis)
end = time.time()
time_taken = end - start
if time_taken < 0.00000111111111111111:
"""
the fact that the time is so low is not due to a super efficient algo, rather it is a quirk in the
scheduler and is to be expected, but doesnt really matter
"""
interesting_dice.append((board.dice, time_taken))
run_times.append(end - start)
del word_list, start, end, board
print(
f"\tAverage run time over {num_runs} random boards was: {(sum(run_times) / len(run_times)) * 1000:.{Config.PRECISION}f}ms (total:{sum(run_times):.{Config.PRECISION}f}s)"
)
print(
f"\t\tMaximum run time was {max(run_times) * 1000:.{Config.PRECISION}f}ms"
)
print(f"\t\tMinimum run time was {min(run_times) * 1000}ms")
def overall_test(self, number_of_runs=None):
"""
Run the algo `number_of_runs` times to see how the application works as a whole
:return:
"""
print("\nStarting overall test...")
if not number_of_runs:
number_of_runs = self.runs
start = time.time()
for run in range(number_of_runs):
board = Board()
word_list = self.solver.generate_words(board)
end = time.time()
print(
f"\tAverage across {number_of_runs} runs: {((end - start) * 1000) / number_of_runs:.{Config.PRECISION}f}ms"
)
def update(self, board_id):
"""
게시판 이름 수정 API
:param board_id: 게시판 objectId
:return: message
"""
try:
if not g.master_role:
return jsonify(message='권한이 없는 사용자입니다.'), 403
data = BoardUpdateSchema().load(json.loads(request.data))
board = Board.objects(id=board_id, is_deleted=False).get()
if board.is_duplicate(data['name']):
return jsonify(message='이미 등록된 게시판입니다.'), 409
board.update(**data)
return '', 200
except ValidationError as err:
return err.messages, 422
def write():
form = BoardForm()
if form.validate_on_submit():
if form.filename.data == None:
filename = ''
else:
filename = secure_filename(form.filename.data.filename)
form.filename.data.save(current_app.config['UPLOAD_FOLDER'] +
filename)
user = User.query.filter_by(
username=current_user.username).first_or_404()
board = Board(author=current_user,
title=form.title.data,
body=form.body.data,
filename=filename)
db.session.add(board)
db.session.commit()
return redirect(url_for('main.board'))
return render_template('edit_profile.html',
title=_('Write anything!'),
form=form,
board=True)
def admin():
users = User.query.all()
if len(users) == 0:
u = User(username='******')
u.set_password('secret-password')
db.session.add(u)
db.session.commit()
boards = Board.query.all()
if len(boards) == 0:
b = Board(ref='b', description='Random talks')
db.session.add(b)
db.session.commit()
# try:
# file = open('test.txt') # наличие флаги будет флагом
# except IOError as e:
# загружаем из бд картинки в систему
# pass
# else:
# print('Not first start, okay.')
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = LoginForm()
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is None or not user.check_password(form.password.data):
flash('Invalid username or password')
return redirect(url_for('main.admin'))
login_user(user, remember=form.remember_me.data)
next_page = request.args.get('next')
if not next_page or url_parse(next_page).netloc != '':
next_page = url_for('main.index')
return redirect(next_page)
return render_template('login.html', title='Sign In', form=form)
def refresh_boards():
"""Refresh from Trello the boards of all organizations"""
for org in Organization.query.all():
for board_id in trello.get_board_ids_by_organization(org.name):
Board.get_or_create(trello.get_board_by_id(board_id))
db.session.commit()
