def get_export_init():
access_user = session.query(User).filter(User.code == api_basic_auth.username()).one()
company_users = session.query(User).filter(
User.company_id == access_user.company_id
).all()
follow = session.query(Follow, User) \
.join(User, Follow.follow_id == User.id) \
.filter(Follow.user_id == access_user.id) \
.one_or_none()
if follow:
follow_user = {'id': follow[1].id, 'name': follow[1].name}
else:
follow_user = None
company_tables = session.query(ShiftTable).filter(ShiftTable.company_id == access_user.company_id).all()
session.close()
return jsonify({
'me': {'id': access_user.id, 'name': access_user.name},
'follow': follow_user,
'users': [{'name': user.name, 'id': user.id} for user in company_users],
'tables': [{'id': table.id, 'title': table.title} for table in company_tables]
}), 200
def update():
schema = {'type': 'object',
'properties':
{'is_shift_import': {'type': 'boolean'},
'is_comment': {'type': 'boolean'},
'is_update_shift': {'type': 'boolean'},
},
'required': ['is_shift_import', 'is_comment', 'is_update_shift']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(User.code == api_basic_auth.username()).one()
user.is_shift_import_notification = request.json['is_shift_import']
user.is_comment_notification = request.json['is_comment']
user.is_update_shift_notification = request.json['is_update_shift']
session.commit()
session.close()
return jsonify({
'is_shift_import': user.is_shift_import_notification,
'is_comment': user.is_comment_notification,
'is_update_shift': user.is_update_shift_notification
}), 200
def update_token():
schema = {
'type': 'object',
'properties': {
'token': {
'type': 'string',
'pattern': '^[0-9a-f]{64}$'
}
},
'required': ['token']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
user.token = request.json['token']
session.commit()
session.close()
return jsonify({'msg': 'OK'}), 200
def get():
admin_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
if admin_user.role.name != 'admin':
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
users_role = session.query(User, Role).join(Role).filter(
User.company_id == admin_user.company_id).order_by(
User.order.asc()).all()
company = session.query(Company).filter(
Company.id == admin_user.company_id).one()
users = []
for user, role in users_role:
users.append({
'name': user.name,
'code': user.code,
'order': user.order,
'role': role.name,
'password': '******' if user.is_authed else user.password
})
session.close()
return jsonify({'results': {'users': users, 'company': company.code}}), 200
def get():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one_or_none()
if user is None:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '指定されたユーザは存在しません',
'param': None
})
salary_tables_results = session.query(Salary, ShiftTable)\
.join(ShiftTable)\
.filter(Salary.user_id == user.id)\
.order_by(Salary.created_at.asc())\
.all()
results = []
for salary, table in salary_tables_results:
results.append({'pay': salary.pay, 'title': table.title})
session.close()
return jsonify({'results': results}), 200
def get():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one_or_none()
session.close()
return jsonify({
'results': {
'daytime_start':
None if user.daytime_start is None else
user.daytime_start.strftime("%H:%M"),
'daytime_end':
None if user.daytime_end is None else
user.daytime_end.strftime("%H:%M"),
'daytime_wage':
None if user.daytime_wage is None else user.daytime_wage,
'night_start':
None if user.night_start is None else
user.night_start.strftime("%H:%M"),
'night_end':
None
if user.night_end is None else user.night_end.strftime("%H:%M"),
'night_wage':
None if user.night_wage is None else user.night_wage
}
}), 200
def get():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
category_results = session.query(ShiftCategory).filter(
ShiftCategory.company_id == user.company_id).all()
scheme_results = session.query(ColorScheme).filter(
ColorScheme.user_id == user.id).all()
results = []
for category in category_results:
scheme_category_match_result = [
x for x in scheme_results if x.shift_category_id == category.id
]
tmp = {'category_id': category.id, 'category_name': category.name}
if len(scheme_category_match_result) == 0:
tmp['hex'] = None
tmp['color_scheme_id'] = None
else:
tmp['hex'] = scheme_category_match_result[0].hex
tmp['color_scheme_id'] = scheme_category_match_result[0].id
results.append(tmp)
session.close()
return jsonify({'results': results}), 200
def get_search_init():
access_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
shift_categories = session.query(ShiftCategory).filter(
ShiftCategory.company_id == access_user.company_id).all()
shifts = session.query(Shift).join(ShiftCategory).filter(
ShiftCategory.company_id == access_user.company_id).all()
users = session.query(User).filter(
User.company_id == access_user.company_id).all()
tables = session.query(ShiftTable).filter(
ShiftTable.company_id == access_user.company_id).all()
session.close()
return jsonify({
'results': {
'category': [{
'id': category.id,
'name': category.name
} for category in shift_categories],
'shift': [{
'id': shift.id,
'name': shift.name
} for shift in shifts],
'user': [{
'id': user.id,
'name': user.name
} for user in users],
'table': [{
'id': table.id,
'title': table.title
} for table in tables]
}
}), 200
def update():
schema = {
'type': 'object',
'properties': {
'username': {
'type': 'string',
'minLength': 1
}
},
'required': ['username']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
if user.code == demo_admin_user['code'] or user.code == demo_general_user[
'code']:
session.close()
return jsonify({'name': user.name}), 200
user.name = request.json['username']
session.commit()
session.close()
return jsonify({'name': request.json['username']}), 200
def get():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
category_shift_results = session.query(ShiftCategory, Shift)\
.outerjoin(Shift, ShiftCategory.id == Shift.shift_category_id) \
.filter(ShiftCategory.company_id == user.company_id)\
.order_by(ShiftCategory.id.asc())\
.all()
results = []
current_category = category_shift_results[0][0]
tmp_shifts = []
for category, shift in category_shift_results:
if current_category == category:
if shift is None:
tmp_shifts = []
else:
tmp_shifts.append({
'id':
shift.id,
'name':
shift.name,
'start':
None
if shift.start is None else shift.start.strftime("%H:%M"),
'end':
None if shift.end is None else shift.end.strftime("%H:%M")
})
else:
results.append({
'category_name': current_category.name,
'category_id': current_category.id,
'shifts': tmp_shifts
})
if shift is None:
tmp_shifts = []
else:
tmp_shifts = [{
'id':
shift.id,
'name':
shift.name,
'start':
None
if shift.start is None else shift.start.strftime("%H:%M"),
'end':
None if shift.end is None else shift.end.strftime("%H:%M")
}]
current_category = category
results.append({
'category_name': current_category.name,
'category_id': current_category.id,
'shifts': tmp_shifts
})
session.close()
return jsonify({'results': results}), 200
def login():
user_role_results = session.query(User, Role).join(Role).filter(User.code == api_basic_auth.username()).one_or_none()
session.close()
if user_role_results is not None:
return jsonify({'user_code': user_role_results[0].code, 'role': user_role_results[1].name}), 200
else:
frame = inspect.currentframe()
abort(404, {'code': frame.f_lineno, 'msg': 'ログインに失敗しました。ログイン情報を再確認してください。', 'param': None})
def get():
user = session.query(User).filter(User.code == api_basic_auth.username()).one_or_none()
session.close()
return jsonify({
'is_shift_import': user.is_shift_import_notification,
'is_comment': user.is_comment_notification,
'is_update_shift': user.is_update_shift_notification
}), 200
def create_or_update_or_delete():
schema = {
'type': 'object',
'properties': {
'username': {
'type': 'string'
}
},
'required': ['username']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
access_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
if access_user.code == demo_admin_user[
'code'] or access_user.code == demo_general_user['code']:
session.close()
return jsonify({'name': request.json['username']}), 200
follow = session.query(Follow).filter(
Follow.user_id == access_user.id).one_or_none()
new_follow_user = session.query(User).filter(
User.name == request.json['username'], User.id != access_user.id,
User.company_id == access_user.company_id).one_or_none()
if len(request.json['username']) == 0:
if follow:
session.delete(follow)
else:
if not new_follow_user:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '対象ユーザが見つかりませんでした',
'param': None
})
if follow:
follow.follow_id = new_follow_user.id
else:
new_follow = Follow(user_id=access_user.id,
follow_id=new_follow_user.id)
session.add(new_follow)
session.commit()
session.close()
return jsonify({'name': request.json['username']}), 200
def delete(table_id):
from app import client
user = session.query(User).filter(User.code == api_basic_auth.username()).one()
if user.role.name != 'admin':
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
table = session.query(ShiftTable).filter(ShiftTable.id == table_id).one_or_none()
if table is None:
session.close()
frame = inspect.currentframe()
abort(404, {'code': frame.f_lineno, 'msg': '指定された取り込み済みのシフトはありません', 'param': None})
if table.company_id != user.company_id:
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
if user.code != demo_admin_user['code']:
os.remove(table.origin_path)
os.remove(table.thumbnail_path)
company_users = session.query(User) \
.filter(User.company_id == user.company_id,
User.token != None, # is not Noneとかでは正しく比較されない
User.id != user.id,
User.is_shift_import_notification == True
) \
.all()
if len(company_users) != 0:
tokens = [user.token for user in company_users]
alert = '{}が{}を削除しました'.format(user.name, table.title)
res = client.send(tokens,
alert,
sound='default',
badge=1,
category='usershift',
extra={'updated': DT.strftime(datetime.datetime.now(), '%Y-%m-%d')}
)
print('***************Add Comment*****************')
print(res.errors)
print(res.token_errors)
print('***************Add Comment*****************')
session.delete(table)
session.commit()
session.close()
return jsonify({'msg': 'OK'}), 200
def update(usershift_id):
schema = {
'type': 'object',
'properties': {
'text': {
'type': 'string'
}
},
'required': ['text']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
user_shift = session.query(UserShift).filter(
UserShift.id == usershift_id).one_or_none()
if user_shift is None:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '対象となるシフトが見つかりませんでした',
'param': None
})
if user_shift.user_id != user.id:
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
user_shift.memo = request.json['text']
session.commit()
session.close()
return jsonify({
'results': {
'usershift_id': user_shift.id,
'date': str(user_shift.date),
'user_id': user_shift.user_id,
'memo': user_shift.memo
}
}), 200
def get():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
shift_categories = session.query(ShiftCategory).filter(
ShiftCategory.company_id == user.company_id).all()
results = []
for category in shift_categories:
results.append({
'category_id': category.id,
'category_name': category.name
})
session.close()
return jsonify({'results': results}), 200
def get_detail(table_id):
table = session.query(ShiftTable).filter(ShiftTable.id == table_id).one_or_none()
if table is None:
session.close()
frame = inspect.currentframe()
abort(404, {'code': frame.f_lineno, 'msg': '指定された取り込み済みのシフトはありません', 'param': None})
user = session.query(User).filter(User.code == api_basic_auth.username()).one()
if user.company_id != table.company_id:
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
comment_user = session.query(Comment, User)\
.join(User).\
filter(Comment.shifttable_id == table.id)\
.order_by(Comment.created_at.desc())\
.all()
comment_list = []
for comment, user in comment_user:
comment_list.append({
'text': comment.text,
'id': comment.id,
'user_id': user.id,
'user': user.name,
'created_at': comment.created_at.strftime('%Y-%m-%d %H:%M')
})
results = {
'table_id': table.id,
'title': table.title,
'origin': table.origin_path,
'start': str(table.start),
'end': str(table.end),
'comment': comment_list
}
session.close()
return jsonify({'results': results}), 200
def update():
schema = {'type': 'object',
'properties':
{'new_password': {'type': 'string', 'minLength': 7}},
'required': ['new_password']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(User.code == api_basic_auth.username()).one()
user.password = generate_password_hash(request.json['new_password'])
session.commit()
session.close()
return jsonify({'msg': 'OK'}), 200
def get_all():
offset = request.args.get('offset', default=0, type=int)
user = session.query(User).filter(User.code == api_basic_auth.username()).one()
tables = session.query(ShiftTable)\
.filter(ShiftTable.company_id == user.company_id)\
.order_by(ShiftTable.start.desc())\
.limit(10).offset(offset).all()
results = []
for table in tables:
results.append({
'table_id': table.id,
'title': table.title,
'origin': table.origin_path,
'thumbnail': table.thumbnail_path,
'start': str(table.start),
'end': str(table.end)
})
session.close()
return jsonify({'results': results}), 200
def get_user_shift():
user_id = request.args.get('user_id', default=-1, type=int)
table_id = request.args.get('table_id', default=-1, type=int)
if user_id == -1 or table_id == -1:
session.close()
frame = inspect.currentframe()
abort(400, {
'code': frame.f_lineno,
'msg': 'IDの指定方法が間違っています',
'param': None
})
shifts = session.query(UserShift, Shift).join(Shift).filter(
UserShift.user_id == user_id,
UserShift.shift_table_id == table_id).all()
shift_results = []
for shift in shifts:
shift_results.append({
'user':
shift[0].user.name,
'shift':
shift[1].name,
'date':
str(shift[0].date),
'start':
None if shift[1].start is None else str(shift[1].start),
'end':
None if shift[1].end is None else str(shift[1].end),
'memo':
shift[0].memo
if api_basic_auth.username() == shift[0].user.code else None
})
session.close()
return jsonify({'results': shift_results}), 200
def search():
access_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
user_id = request.args.get('user_id', default=-1, type=int)
category_id = request.args.get('category_id', default=-1, type=int)
table_id = request.args.get('table_id', default=-1, type=int)
shift_id = request.args.get('shift_id', default=-1, type=int)
user_id_statement = True if user_id == -1 else UserShift.user_id == user_id
table_id_statement = True if table_id == -1 else UserShift.shift_table_id == table_id
shift_id_statement = True if shift_id == -1 else UserShift.shift_id == shift_id
category_id_statement = True if category_id == -1 else ShiftCategory.id == category_id
query_results = session.query(UserShift).join(
Shift, ShiftCategory,
Company).filter(Company.id == access_user.company_id,
user_id_statement, table_id_statement,
shift_id_statement, category_id_statement).all()
query_results.sort(key=lambda user_shift: user_shift.date)
results = []
for date, date_group in groupby(query_results,
key=lambda user_shift: user_shift.date):
results.append({
'date':
str(date),
'shift': [{
'id': user_shift.id,
'user': user_shift.user.name,
'name': user_shift.shift.name
} for user_shift in list(date_group)]
})
session.close()
return jsonify({'results': results}), 200
def get():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one_or_none()
if user is None:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '指定された企業情報が見つかりませんでした',
'param': None
})
company = session.query(Company).filter(
Company.id == user.company_id).one()
session.close()
return jsonify({
'same_line_threshold': company.default_same_line_threshold,
'username_threshold': company.default_username_threshold,
'join_threshold': company.default_join_threshold,
'day_shift_threshold': company.default_day_shift_threshold
}), 200
def get():
users = []
access_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
company_users = session.query(User).filter(
User.company_id == access_user.company_id,
User.id != access_user.id).all()
for user in company_users:
users.append(user.name)
follow = session.query(Follow, User)\
.join(User, Follow.follow_id == User.id)\
.filter(Follow.user_id == access_user.id)\
.one_or_none()
if follow:
follow_name = follow[1].name
else:
follow_name = None
session.close()
return jsonify({'results': {'users': users, 'follow': follow_name}}), 200
def unknown_update():
from app import client
schema = {
'type': 'object',
'properties': {
'updates': {
'type': 'array',
'items': {
'type': 'object',
'properties': {
'code': {
'type': 'string',
'pattern': '^[0-9]{7}$'
},
'date': {
'type': 'string',
'pattern': '^[0-9]{4}-[0-9]{2}-[0-9]{2}$'
},
'name': {
'type': 'string',
'minLength': 1
}
}
}
}
},
'required': ['updates']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
admin_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
if admin_user.role.name != 'admin':
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
alert_tokens = []
for new_shift in request.json['updates']:
shift = session.query(Shift).join(ShiftCategory).filter(
Shift.name == new_shift['name'],
ShiftCategory.company_id == admin_user.company_id).one_or_none()
user = session.query(User).filter(
User.code == new_shift['code']).one_or_none()
if shift is None or user is None:
session.close()
frame = inspect.currentframe()
abort(
404, {
'code': frame.f_lineno,
'msg': '変更対象のシフトが見つかりませんでした',
'param': None
})
user_shift_result = session.query(UserShift)\
.filter(UserShift.user_id == user.id,
UserShift.date == new_shift['date']
).one_or_none()
if user_shift_result is None:
session.close()
frame = inspect.currentframe()
abort(
404, {
'code': frame.f_lineno,
'msg': '変更対象のシフトが見つかりませんでした',
'param': None
})
old_shift_name = user_shift_result.shift.name
user_shift_result.shift_id = shift.id
session.commit()
if user.is_update_shift_notification is True and user.token is not None and user.id != admin_user.id and admin_user.code != demo_admin_user[
'code']:
alert = '{}が{}のシフトを{}から{}へ変更しました'.format(
admin_user.name, str(user_shift_result.date), old_shift_name,
shift.name)
alert_tokens.append({
'alert': alert,
'token': user.token,
'updated': str(user_shift_result.date)
})
session.close()
for alert_token in alert_tokens:
res = client.send(alert_token['token'],
alert_token['alert'],
sound='default',
badge=1,
category='usershift',
extra={'updated': alert_token['updated']})
print('***************Update UserShift*****************')
print(res.errors)
print(res.token_errors)
print('***************Update UserShift*****************')
return jsonify({'msg': 'OK'}), 200
def get():
access_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
shit_results = []
start = request.args.get('start', default='', type=str)
end = request.args.get('end', default='', type=str)
try:
start = DT.strptime(start, '%Y%m%d')
end = DT.strptime(end, '%Y%m%d')
except ValueError:
session.close()
frame = inspect.currentframe()
abort(400, {
'code': frame.f_lineno,
'msg': '開始日と終了日の指定方法が間違っています',
'param': None
})
start.isoformat()
start.isoformat()
end.isoformat()
end.isoformat()
start = start.date()
end = end.date()
follow = session.query(Follow, User)\
.join(User, Follow.follow_id == User.id)\
.filter(Follow.user_id == access_user.id)\
.one_or_none()
# フォロー設定が有効だった場合はシフト抽出に使用するユーザをフォローしているユーザにする
if follow:
current_user = session.query(User).filter(
User.id == follow[1].id).one()
else:
current_user = access_user
'''
指定範囲のシフト情報を抽出
'''
user_shift = session.query(UserShift, Shift, ShiftCategory, User)\
.join(User, Company, Shift, ShiftCategory)\
.filter(UserShift.date.between(start, end), User.company_id == current_user.company_id).all()
# アクセスしたユーザがカラー設定を全て行なっているかを判定
is_all_color_setting = False
if follow:
shift_category_results = session.query(ShiftCategory).filter(
ShiftCategory.company_id == access_user.company_id).all()
access_user_color_results = session.query(ColorScheme).filter(
ColorScheme.user_id == access_user.id).all()
is_all_color_setting = True if len(shift_category_results) == len(
access_user_color_results) else False
if not (follow and is_all_color_setting):
access_user_color_results = session.query(ColorScheme).filter(
ColorScheme.user_id == current_user.id).all()
# 日付でグルーピング
user_shift.sort(key=lambda tmp_user_shift: tmp_user_shift[0].date)
for date, date_group in groupby(
user_shift, key=lambda tmp_user_shift: tmp_user_shift[0].date):
tmp_shift_group = []
memo = None
current_user_shift = None
# シフトカテゴリのidでグルーピング
date_group = list(date_group)
date_group.sort(key=lambda tmp_user_shift: tmp_user_shift[2].id)
for shift_category, shift_category_group in groupby(
date_group, key=lambda tmp_user_shift: tmp_user_shift[2].name):
users_shift = []
for shift in shift_category_group:
if shift[3].code == current_user.code:
# フォロー設定が有効な場合は他の人のメモが表示されるのでNoneを返す
memo = None if follow else shift[0].memo
# フォロー設定が有効かつアクセスしたユーザのカラー設定が全て行われている場合はアクセスしたユーザのカラーを返す
color_search_result = [
color for color in access_user_color_results
if color.shift_category_id == shift[2].id
]
if len(color_search_result) == 0:
hex = None
else:
hex = color_search_result[0].hex
current_user_shift = {
'user': shift[3].name,
'shift_id': shift[0].id,
'shift_name': shift[1].name,
'color': hex
}
users_shift.append({
'user': shift[3].name,
'shift_id': shift[0].id,
'shift_name': shift[1].name
})
tmp_shift_group.append({shift_category: users_shift})
shit_results.append({
'date': str(date),
'shift_group': tmp_shift_group,
'user_shift': current_user_shift,
'memo': memo
})
session.close()
return jsonify({
'results': {
'shift': shit_results,
'is_following': True if follow else False
}
}), 200
def get():
range = request.args.get('range', default='', type=str)
access_user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
follow = session.query(Follow, User) \
.join(User, Follow.follow_id == User.id) \
.filter(Follow.user_id == access_user.id) \
.one_or_none()
if follow:
current_user = session.query(User).filter(
User.id == follow[1].id).one()
else:
current_user = access_user
if range == 'latest':
offset = 0
limit = 1
elif range == 'prev':
offset = 0
limit = 2
elif range == 'all':
offset = request.args.get('offset', default=0, type=int)
limit = 5
else:
session.close()
frame = inspect.currentframe()
abort(400, {
'code': frame.f_lineno,
'msg': '範囲の指定方法が間違っています',
'param': None
})
tables = session.query(ShiftTable).filter(
ShiftTable.company_id == current_user.company_id).order_by(
ShiftTable.start.desc()).limit(limit).offset(offset).all()
shift_category_results = session.query(ShiftCategory).filter(
ShiftCategory.company_id == access_user.company_id).order_by(
ShiftCategory.id.asc()).all()
# アクセスしたユーザがカラー設定を全て行なっているかを判定
is_all_color_setting = False
if follow:
access_user_color_results = session.query(ColorScheme).filter(
ColorScheme.user_id == access_user.id).all()
is_all_color_setting = True if len(shift_category_results) == len(
access_user_color_results) else False
if not (follow and is_all_color_setting):
current_user_color_results = session.query(ColorScheme).filter(
ColorScheme.user_id == current_user.id).all()
else:
current_user_color_results = access_user_color_results
results = []
for table in tables:
user_shift_category = session.query(UserShift, ShiftCategory).join(
ShiftTable, Shift,
ShiftCategory).filter(UserShift.user_id == current_user.id,
ShiftTable.id == table.id).all()
counter_dict = dict(
collections.Counter([
user_shift_category[1].id
for user_shift_category in user_shift_category
]))
categories = []
for shift_category in shift_category_results:
# ループの対象となっているカテゴリーidと一致するcolorを検索
color_scheme_search_results = [
color_scheme for color_scheme in current_user_color_results
if color_scheme.shift_category_id == shift_category.id
]
hex = None if len(color_scheme_search_results
) == 0 else color_scheme_search_results[0].hex
if shift_category.id in counter_dict.keys():
categories.append({
'count': counter_dict[shift_category.id],
'name': shift_category.name,
'hex': hex
})
else:
categories.append({
'count': 0,
'name': shift_category.name,
'hex': hex
})
results.append({
'category': categories,
'title': table.title,
'start': str(table.start),
'end': str(table.end)
})
session.close()
return jsonify({
'results': {
'table': results,
'follow': follow[1].name if follow else ''
}
}), 200
def create_or_update_or_delete():
schema = {
'type': 'object',
'properties': {
'schemes': {
'type': 'array',
'items': {
'type': 'object',
'properties': {
'category_id': {
'type': 'integer',
'minimum': 0
},
'hex': {
'type': 'string',
'pattern': '^#([0-9]|[A-F]){6}$'
}
},
'required': ['category_id', 'hex']
}
},
},
'required': ['schemes']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
for schema in request.json['schemes']:
category = session.query(ShiftCategory).filter(
ShiftCategory.id == schema['category_id']).one_or_none()
if not category:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '対応するシフトカテゴリがありません',
'param': None
})
if category.company_id != user.company_id:
session.close()
frame = inspect.currentframe()
abort(403, {
'code': frame.f_lineno,
'msg': '権限がありません',
'param': None
})
color = session.query(ColorScheme).filter(
ColorScheme.user_id == user.id,
ColorScheme.shift_category_id == category.id).one_or_none()
if color is None:
if schema['hex'] != '#FFFFFF':
new_color = ColorScheme(hex=schema['hex'],
user_id=user.id,
shift_category_id=category.id)
session.add(new_color)
else:
if schema['hex'] == '#FFFFFF':
session.delete(color)
else:
color.hex = schema['hex']
session.commit()
session.close()
return jsonify({'results': 'OK'}), 200
def add_update_delete():
schema = {
'type': 'object',
'properties': {
'adds': {
'type': 'array',
'items': {
'type': 'object',
'properties': {
'category_id': {
'type': 'integer',
'minimum': 0
},
'start': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$|'
},
'end': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$|'
},
'name': {
'type': 'string',
'minLength': 1
}
},
'required': ['category_id', 'start', 'end', 'name']
}
},
'updates': {
'type': 'array',
'items': {
'type': 'object',
'properties': {
'id': {
'type': 'integer',
'minimum': 0
},
'category_id': {
'type': 'integer',
'minimum': 0
},
'start': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$|'
},
'end': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$|'
},
'name': {
'type': 'string',
'minLength': 1
}
},
'required': ['id', 'category_id', 'start', 'end', 'name']
}
},
'deletes': {
'type': 'array',
'items': {
'type': 'integer'
}
}
},
'required': ['adds', 'updates', 'deletes']
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
admin_user = session.query(User).filter(
User.code == api_basic_auth.username()).one_or_none()
if admin_user.role.name != 'admin':
session.close()
frame = inspect.currentframe()
abort(403, {'code': frame.f_lineno, 'msg': '権限がありません', 'param': None})
for shift_id in request.json['deletes']:
shift_company_results = session.query(Shift, Company).join(
ShiftCategory, Company).filter(Shift.id == shift_id).one_or_none()
if shift_company_results is None:
session.close()
frame = inspect.currentframe()
abort(
404, {
'code': frame.f_lineno,
'msg': '変更対象のシフトが見つかりませんでした',
'param': None
})
if admin_user.company_id != shift_company_results[1].id:
session.close()
frame = inspect.currentframe()
abort(403, {
'code': frame.f_lineno,
'msg': '権限がありません',
'param': None
})
session.delete(shift_company_results[0])
for shift_obj in request.json['updates']:
shift_company_results = session.query(Shift, Company).join(
ShiftCategory,
Company).filter(Shift.id == shift_obj['id']).one_or_none()
if shift_company_results is None:
session.close()
frame = inspect.currentframe()
abort(
404, {
'code': frame.f_lineno,
'msg': '変更対象のシフトが見つかりませんでした',
'param': None
})
if admin_user.company_id != shift_company_results[1].id:
session.close()
frame = inspect.currentframe()
abort(403, {
'code': frame.f_lineno,
'msg': '権限がありません',
'param': None
})
shift_category = session.query(ShiftCategory).filter(
ShiftCategory.id == shift_obj['category_id']).one_or_none()
if shift_category is None:
session.close()
frame = inspect.currentframe()
abort(
404, {
'code': frame.f_lineno,
'msg': '関連するシフトカテゴリが見つかりませんでした',
'param': None
})
shift_company_results[0].name = shift_obj['name']
shift_company_results[0].shift_category_id = shift_category.id
shift_company_results[
0].start = None if shift_obj['start'] == '' else shift_obj['start']
shift_company_results[
0].end = None if shift_obj['end'] == '' else shift_obj['end']
session.commit()
for shift_obj in request.json['adds']:
shift_category = session.query(ShiftCategory).filter(
ShiftCategory.id == shift_obj['category_id']).one_or_none()
if shift_category.company_id != admin_user.company_id:
session.close()
frame = inspect.currentframe()
abort(403, {
'code': frame.f_lineno,
'msg': '権限がありません',
'param': None
})
shift = session.query(Shift).join(ShiftCategory, Company).filter(
Shift.name == shift_obj['name'],
Company.id == admin_user.company_id).one_or_none()
if shift is not None:
session.close()
frame = inspect.currentframe()
abort(
409, {
'code': frame.f_lineno,
'msg': '既に同じシフトが存在しているため、新しいシフトを追加できませんでした。',
'param': None
})
new_shift = Shift(
name=shift_obj['name'],
shift_category_id=shift_category.id,
start=None if shift_obj['start'] is '' else shift_obj['start'],
end=None if shift_obj['end'] is '' else shift_obj['end'])
session.add(new_shift)
session.commit()
session.close()
return jsonify({'msg': 'OK'}), 200
def update():
schema = {
'type':
'object',
'properties': {
'daytime_start': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$'
},
'daytime_end': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$'
},
'night_start': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$'
},
'night_end': {
'type': 'string',
'pattern': '^[0-9]{2}:[0-9]{2}$'
},
'daytime_wage': {
'type': 'number',
'minimum': 1
},
'night_wage': {
'type': 'number',
'minimum': 1
}
},
'required': [
'daytime_start', 'daytime_end', 'night_start', 'night_end',
'daytime_wage', 'night_wage'
]
}
try:
validate(request.json, schema)
except ValidationError as e:
session.close()
frame = inspect.currentframe()
abort(400, {'code': frame.f_lineno, 'msg': e.message, 'param': None})
user = session.query(User).filter(
User.code == api_basic_auth.username()).one()
user.daytime_start = request.json['daytime_start']
user.daytime_end = request.json['daytime_end']
user.daytime_wage = request.json['daytime_wage']
user.night_start = request.json['night_start']
user.night_end = request.json['night_end']
user.night_wage = request.json['night_wage']
session.commit()
session.close()
return jsonify({
'results': {
'daytime_start': str(user.daytime_start),
'daytime_end': str(user.daytime_end),
'daytime_wage': user.daytime_wage,
'night_start': str(user.night_start),
'night_end': str(user.night_end),
'night_wage': user.night_wage
}
}), 200
def update():
user = session.query(User).filter(
User.code == api_basic_auth.username()).one_or_none()
if user is None:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '指定されたユーザは存在しません',
'param': None
})
table_usershift_results = session.query(ShiftTable, UserShift, Shift)\
.join(UserShift, ShiftTable.id == UserShift.shift_table_id)\
.join(Shift, UserShift.shift_id == Shift.id)\
.filter(UserShift.user_id == user.id)\
.all()
if len(table_usershift_results) == 0:
session.close()
frame = inspect.currentframe()
abort(404, {
'code': frame.f_lineno,
'msg': '該当するシフト情報が見つかりませんでした',
'param': None
})
current_table_id = table_usershift_results[0][0].id
tmp_salary = 0
for table, user_shift, shift in table_usershift_results:
if current_table_id == table.id:
tmp_salary += get_salary(user, shift)
else:
salary = session.query(Salary).filter(
Salary.user_id == user.id,
Salary.shifttable_id == current_table_id).one_or_none()
if salary is None:
new_salary = Salary(pay=tmp_salary,
user_id=user.id,
shifttable_id=current_table_id)
session.add(new_salary)
else:
salary.pay = tmp_salary
current_table_id = table.id
tmp_salary = 0
salary = session.query(Salary).filter(
Salary.user_id == user.id,
Salary.shifttable_id == current_table_id).one_or_none()
if salary is None:
new_salary = Salary(pay=tmp_salary,
user_id=user.id,
shifttable_id=current_table_id)
session.add(new_salary)
else:
salary.pay = tmp_salary
session.commit()
salary_tables_results = session.query(Salary, ShiftTable)\
.join(ShiftTable)\
.filter(Salary.user_id == user.id)\
.order_by(Salary.created_at.asc())\
.all()
results = []
for salary, table in salary_tables_results:
results.append({'pay': salary.pay, 'title': table.title})
session.close()
return jsonify({'results': results}), 200
