def create_app_user_roles():
roles = [
{"name": "Guest", "description": "User that has not logged in and can only view public sheets."},
{"name": "Undergraduate", "description": "User that can import and view their own sheets with restrictions."},
{"name": "Graduate", "description": "User that can import and view their own sheets with no restrictions."},
{"name": "Teacher", "description": "User that can import and view their own sheets, plus add other users that will be able to view their sheets."},
{"name": "Super User", "description": "User with access to all app features."},
{"name": "Blocked", "description": "User is not allowed to access the App."}
]
role_ids = {}
for role in roles:
role_entry = app_user_role(
aur_role_name=role['name'],
aur_role_description=role['description'],
aur_created=datetime.utcnow(),
aur_last_modified=datetime.utcnow()
)
db_session.add(role_entry)
db_session.flush()
role_ids[role['name']] = role_entry.aur_id
db_session.commit()
return role_ids
def _acquire_room_number(self, number): """部屋番号をプールに返却""" rnp = self._get_rnp() numbers = sorted(loads(rnp.jsonstring)) numbers.append(number) rnp.jsonstring = dumps(numbers) db_session.flush()
def _save_session(self, hostname, user):
"""make_room(新規ゲーム), join_room(参加表明)のとき、会員のFQDNとIPアドレスを記録する。"""
try:
ipaddr = unicode(socket.gethostbyname(hostname))
except socket.gaierror: # DNSが引けないとかネット切断とか
ipaddr = None
db_session.add(Session(int(time.time()), hostname, ipaddr, user.id))
db_session.flush()
def _pick_room_number(self): """部屋番号をプールから取得""" rnp = self._get_rnp() numbers = sorted(loads(rnp.jsonstring)) room_number = numbers.pop(0) rnp.jsonstring = dumps(numbers) db_session.flush() return room_number
def make_room(users):
owner, users = users_random_pop(users)
gr = GeneralRecord(int(time.time()), u"#たまひよ", tama._pick_room_number(), owner.name)
gr.game_ipaddr = u"127.0.0.1"
db_session.add(gr)
db_session.flush()
pr = PersonalRecord(owner.id, gr.id)
db_session.add(pr)
db_session.flush()
return gr.id, owner, users
def _execute_breakup(self, gr):
"""部屋を解散する。"""
gr.active = False
gr.brokeup = True
members = []
for pr in gr.personal_records:
if pr.active:
pr.active = False
members.append(pr)
db_session.flush()
self._acquire_room_number(gr.room_number)
return members
def accounts_add(user):
schema = {
"type": "object",
"properties": {
"folder_id": {"type": "integer"},
"encrypted_account_data": {
"type": "array",
"items": {
"type": "object",
"properties": {
"user_id": {"type": "integer"},
"password": {"type": "string"},
"account_metadata": {"type": "string"},
"encrypted_aes_key": {"type": "string"},
},
"required": ["user_id", "password", "encrypted_aes_key",
"account_metadata"]
}
}
},
"required": ["folder_id", "encrypted_account_data"]
}
error = validate_schema(request.json, schema)
folder_id = request.json["folder_id"]
encrypted_account_data = request.json["encrypted_account_data"]
f = Folder.query.get(folder_id)
if not f:
return error_response("item_not_found", "Folder not found")
if not f.user_can_write(user):
return error_response("insufficient_permissions", "You do not have "
"write permission for this folder")
a = Account(folder_id=folder_id)
db_session.add(a)
db_session.flush()
for item in encrypted_account_data:
db_session.add(AccountDataItem(
user_id=item["user_id"],
account_id=a.id,
password=item["password"],
account_metadata=item["account_metadata"],
encrypted_aes_key=item["encrypted_aes_key"],
))
db_session.commit()
return jsonify(account_id=a.id)
def _team_assign(self, general_record):
"""任意の人数をチーム分け"""
# 10進数（自然数）をn進数に変換する関数。拾い物。動作確認済み
def convert_natural_radix_10_to_n(x, n):
if x < 0: return None
if n < 2 or 16 < n: return None
if x == 0: return 0
nchar = '0123456789ABCDEF'
digit = 0
result = ''
while x > 0:
result = nchar[x % n] + result
x = x / n
return result
prs = self._get_inside_member_prs(general_record=general_record)
pop = len(prs)
num_of_digits = pop - int(pop / 2.0) #奇数の場合人数の多い方を理想レートに近づける
rates = [pr.user.rate for pr in prs]
ideal = sum(rates) / 2.0 # 総和の1/2が理想とする
idx_and_IdealDegree = [] # 組み合わせごとの理想度をメモするリスト
# pop進数のチーム人数桁まで考えればよい
for i in range(pop**num_of_digits):
some_idx = [int(s) for s in str(convert_natural_radix_10_to_n(i, pop)).rjust(num_of_digits, "0")]
# そのうち同じ人が同じチームに二度以上入る組み合わせを取り除く
idx_one_by_one = list(set(some_idx))
if len(idx_one_by_one) == num_of_digits:
# 理想との差を理想度とする
ideal_degree = abs(ideal - sum([rates[idx] for idx in idx_one_by_one]))
idx_and_IdealDegree.append((idx_one_by_one, ideal_degree))
# 理想との差が少ない順にソート
idx_and_IdealDegree.sort(key=lambda element: element[1])
most_ideally_combination_idx = idx_and_IdealDegree[0][0]
# pop()で要素を取り出すとindexが切り詰められるので、末尾からpop()する
mici = sorted(most_ideally_combination_idx, reverse=True)
team1 = [prs.pop(idx) for idx in mici]
team2 = prs
for pr in team1:
pr.team = conf.TEAM1
for pr in team2:
pr.team = conf.TEAM2
# チーム分け当時のレートを保存。勝敗による変動レート計算用。
# これがないとゲーム中にレートが手動で修正されたとき、チームの合計レートが
# 変わるせいで、勝敗によるレート変動に過不足が出る。
for pr in team1 + team2:
pr.rate_at_umari = pr.user.rate
db_session.flush()
def _rollback_result(self, gr):
"""勝敗の付け間違いに伴う、誤った勝敗数と、誤ったレート変動を差し戻す。"""
members = db_session.query(PersonalRecord
).filter(PersonalRecord.general_record_id == gr.id
).filter(PersonalRecord.won != None
).all()
for pr in members:
if pr.won:
pr.user.won_count -= 1
else:
pr.user.lost_count -= 1
if gr.rating_match:
pr.user.rate = pr.user.rate - (pr.change_width if pr.won else -pr.change_width)
db_session.flush()
return members
def iam(self, json): # Web版のみにしないとまずい気が
"""別名登録"""
args = loads(json)
print args
user = self._whoami(args["alias"], alias_contain=False)
if user is not None:
return dumps((False,))
user = self._whoami(args["original_name"], alias_contain=False)
if user is None:
return dumps((False,))
db_session.add(UserAlias(args["alias"], user.id))
try:
db_session.flush()
except IntegrityError:
db_session.rollback()
return dumps((False,))
db_session.commit()
return dumps((True,))
def delete_blog():
title = request.form['title']
print title
delete_blog_post = db_session.query(Blog_Post).first()
show = db_session.relationship('Show',
backref=db.backref('episodes', cascade="all, delete-orphan"),
lazy='joined')
print delete_blog_post
db_session.delete(delete_comments)
db_session.delete(delete_blog_post)
try:
print "succsess"
db_session.commit()
except Exception as e:
print "error"
db_session.rollback()
db_session.flush()
return redirect(url_for('routes.add_blog'))
def add_blog():
if request.method == 'POST':
error = False
title = request.form['title']
sub_title = request.form['subtitle']
content = request.form['content']
new_blog_post = Blog_Post(title, sub_title, content)
db_session.add(new_blog_post)
try:
db_session.commit()
except Exception as e:
error = True
db_session.rollback()
db_session.flush()
return redirect(url_for('routes.blog_post', blog_post_title=title))
if 'logged_in' in session:
blog_posts = db_session.query(Blog_Post).all()
return render_template("addpost.html", blog_posts = blog_posts)
else:
return redirect(url_for('routes.check_admin'))
def join_room(self, json):
"""入室。参加者は8人まで。 8人になると自動でチーム分けされる。"""
args = loads(json)
print args
user = self._whoami(args["caller"])
if user is None:
return dumps((False,))
if self._get_active_pr(user):
return dumps((False,))
gr = self._get_dst_gr(args["channel"], args["room_number"])
if gr is None:
return dumps((False,))
if gr.umari_at:
return dumps((False,))
if gr.umari_at is not None:
return dumps((False,))
# TODO: レート制限のテスト
if gr.rate_limit:
if gr.rate_limit < user.rate:
return dumps((False,))
self._join_to_room(user, gr)
db_session.commit()
members = self._get_inside_member_prs(general_record=gr)
print "******"
print len(members)
if len(members) == 8:
gr.umari_at = int(time.time())
gr.rating_match = True
db_session.flush()
self._team_assign(gr)
print [gr.umari_at, gr.rating_match]
self._save_session(args["hostname"], user)
db_session.commit()
params = self._construct_room_info(gr, user)
session_diff = self._diff_session(user)
if session_diff:
params.update({"session_diff": session_diff})
return dumps((True, params))
def create_sheet_status_defaults():
statuses = [
{"name": "Private", "description": "Sheet can only be seen by user who added the sheet."},
{"name": "Review Requested", "description": "User has requested to make the sheet available publicly."},
{"name": "Public", "description": "Sheet is viewable by all users."},
{"name": "Deleted", "description": "Sheet has been deleted."},
]
status_ids = {}
for status in statuses:
status_entry = sheet_status(
ss_status_name=status['name'],
ss_status_description=status['description'],
ss_created=datetime.utcnow(),
ss_last_modified=datetime.utcnow()
)
db_session.add(status_entry)
db_session.flush()
status_ids[status['name']] = status_entry.ss_id
db_session.commit()
return status_ids
def make_room(self, json):
"""部屋作成、更新"""
args = loads(json)
print args
# 登録されたuserでなければならない
user = self._whoami(args["caller"])
if user is None:
return dumps((False,))
# ホスト以外はどの部屋にも入っていない状態でなければ使えない
owner_pr = self._is_room_owner(args["channel"], args["caller"])
pr = self._get_active_pr(user)
if bool(pr) and (not bool(owner_pr)):
return dumps((False,))
if owner_pr:
gr = owner_pr.general_record
gr.room_name = args["room_name"]
gr.rate_limit = args["rate_limit"]
db_session.flush()
else:
gr = GeneralRecord(int(time.time()), args["channel"], self._pick_room_number(), user.name)
gr.room_name = args["room_name"]
gr.rate_limit = args["rate_limit"]
gr.game_ipaddr = args["ip_addr"]
db_session.add(gr)
db_session.flush()
self._join_to_room(user, gr)
self._save_session(args["hostname"], user)
db_session.commit()
params = self._construct_room_info(gr, user)
session_diff = self._diff_session(user)
if session_diff:
params.update({"session_diff": session_diff})
return dumps((True, params))
def _save_result(self, owner_pr, won, rollback=False):
"""勝敗をつける。rollback=Trueは、訂正モード"""
gr = owner_pr.general_record
enemy_team = conf.TEAM2 if conf.TEAM1 == owner_pr.team else conf.TEAM1
gr.winner = owner_pr.team if won else enemy_team
gr.completed_at = int(time.time())
gr.active = False
db_session.flush()
self._acquire_room_number(gr.room_number)
if rollback:
members = self._rollback_result(gr)
else:
members = []
for pr in gr.personal_records:
if pr.active:
members.append(pr)
pr.user.last_game_timestamp = int(time.time())
for pr in members:
pr.won = True if pr.team == gr.winner else False
pr.active = False
if pr.won:
pr.user.won_count += 1
else:
pr.user.lost_count += 1
if gr.rating_match:
cw = pr.change_width = self._calc_change_width(pr)
pr.user.rate = pr.user.rate + (cw if pr.won else -cw)
pr.determined_rate = pr.rate_at_umari + (cw if pr.won else -cw)
db_session.flush()
# 連勝記録の更新
# 60日以内の勝敗記録
for pr in members:
pr.user.streak = self._get_streak(pr.user)
pr.user.result_last_60_days = self._construct_result_last_60_days(pr.user, pr.won)
db_session.flush()
def join_room1(gr_id, users):
user, users = users_random_pop(users)
pr = PersonalRecord(user.id, gr_id)
db_session.add(pr)
db_session.flush()
return users
def _join_to_room(self, user, general_record): """参加表明""" pr = PersonalRecord(user.id, general_record.id) db_session.add(pr) db_session.flush()
