def sportsfield_add():
form = AddSportFieldForm(request.form)
if not form.validate():
return param_error(form.errors)
cur_user = UserInfo.query.filter_by(
id=current_user.id, record_status=const.record_normal).first()
if not cur_user:
return reply(success=False,
message='内部出错，请联系管理员',
error_code=const.code_inner_err)
gym_id = form.gym_id.data
gym_rel = Gym.query.filter_by(id=gym_id, record_status=const.record_normal)
if cur_user.user_type > const.user_type_manage and cur_user.user_number != gym_rel.manager_number:
return reply(success=False,
message='无权限',
error_code=const.code_not_permit)
court_data = {
"gym_id": gym_id,
"court_name": form.court_name.data,
"description": form.court_description.data,
"court_type": form.court_type.data,
"court_count": form.court_num.data,
"court_fee": form.court_num.data,
"order_days": form.order_days.data,
"period_class_id": form.period_class_id.data
}
res = add_by_data(Court, court_data)
return reply(success=res[0], message=res[1], error_code=res[2])
def get_order_info():
# method: get
order_id = request.args.get('order_id')
order_table = CourtOrder.query.filter_by(id=order_id).first()
if not order_table:
return reply(success=False,
message="There is no such order!",
error_code=1)
resource_info = CourtResource.query.filter_by(
id=order_table.resource_id).first()
court_info = Court.query.filter_by(id=resource_info.court_id).first()
period_info = PeriodData.query.filter_by(
id=resource_info.period_id).first()
gym_info = Gym.query.filter_by(id=court_info.gym_id).first()
data = {
'order_time': order_table.order_time,
'pay_time': order_table.pay_time,
'paid_money': order_table.amount,
'is_canceled': order_table.is_canceled,
'cancel_time': order_table.cancel_time,
'gym_name': gym_info.gym_name,
'gym_location': gym_info.location,
'court_type': court_info.court_type,
'order_price': court_info.court_fee,
'start_time': str(period_info.start_time),
'end_time': str(period_info.end_time),
'court_number': resource_info.court_number
}
return reply(success=True, data=data, message="")
def delete_department():
form = DeleteByIdForm(request.form)
if not form.validate():
return reply(success=False, message='参数错误', error_code=const.code_param_err)
res = utils.delete_by_id(Department, form.id.data)
return reply(success=res[0], message=res[1], error_code=res[2])
def period_edit():
form = EditPeriodForm(request.form)
if not form.validate():
return param_error(form.errors)
cur_user = UserInfo.query.filter_by(
id=current_user.id, record_status=const.record_normal).first()
if not cur_user:
return reply(success=False,
message='内部出错，请联系管理员',
error_code=const.code_inner_err)
period_class_id = form.period_id.data
period_class_data = PeriodClass.query.filter_by(id=period_class_id)
period_class_exist = period_class_data.first()
if period_class_exist:
update_data = {}
if form.period_class_name.data and form.period_class_name.data != period_class_exist.period_class_name:
update_data['period_class_name'] = form.period_class_name.data
if form.period_description.data and form.period_description.data != period_class_exist.period_class_description:
update_data[
'period_class_description'] = form.period_description.data
res = update_by_data(period_class_data, update_data, True)
return reply(success=res[0], message=res[1], error_code=res[2])
else:
return reply(success=False,
message='找不该时间段类型',
error_code=const.code_param_illegal)
def ordering(id):
admin = 0
if current_user.user_type == const.user_type_admin:
admin = 1
court = Court.query.filter_by(id=id).first()
if not court:
return reply(success=False, message='无对应场馆！', error_code=1)
date_now = datetime.date.today()
dates = []
occupy = {}
periods = [(per.id, per.start_time, per.end_time)
for per in PeriodData.query.filter_by(
period_class_id=court.period_class_id).all()]
periods = [(period[0], period[1].strftime('%H:%M'),
period[2].strftime('%H:%M')) for period in periods]
if not periods:
return reply(success=False, message='无对应时间段！', error_code=2)
for i in range(1, court.order_days + 1):
date = (date_now + datetime.timedelta(days=i))
d = date.strftime('%m.%d')
dates.append(d)
occupy[d] = {}
for period in periods:
occupy[d][period[0]] = {}
court_resource = CourtResource.query.filter_by(date=date,
period_id=period[0],
court_id=id).all()
if not court_resource:
return reply(success=False, message='无场地资源！', error_code=3)
for cr in court_resource:
if cr.occupied:
occupy[d][period[0]][cr.court_number] = 1
else:
if cr.order_count < cr.max_order_count:
occupy[d][period[0]][cr.court_number] = 0
else:
occupy[d][period[0]][cr.court_number] = 2
data = {
'court_id': id,
'dates': dates,
'periods': periods,
'occupy': occupy,
'admin': admin
}
return reply(success=True, data=data, error_code='')
def login():
form = LoginForm(request.form)
if not form.validate():
return param_error(form.errors)
user = UserInfo.query.filter_by(user_number=form.user_number.data,
record_status=const.record_normal).first()
if not user or user.password != form.password.data:
return reply(success=False, message="用户不存在或密码错误")
if user.disabled == const.user_disabled_true:
return reply(success=False, message="账号被冻结，无法登陆")
auth.login(user)
return reply(
success=True,
message="登陆成功",
)
def login():
valid, form = parsing_form('loginForm')
if not valid:
return reply(success=False, message='参数缺失', error_code=const.PARAM_ERR)
user = User.query.filter_by(username=form['username'],
record_status=const.RECORD_NORMAL).first()
if not user:
return reply(success=False,
message='用户不存在',
error_code=const.LOGIN_ERR)
if user.password != form['password']:
return reply(success=False, message='密码错误', error_code=const.LOGIN_ERR)
auth.login(user)
return reply(success=True)
def create_project():
program = request.files["program"]
program.save(osp.join("program", program.filename))
project_name = request.form.get("project_name")
description = request.form.get("description")
types = request.form.get("types")
project = {
"user_name":
current_user.user_name,
"project_name":
project_name,
"description":
description,
"types":
types,
"program_file":
program.filename,
"version_num":
1,
"date":
time.strftime("%Y-%m-%d ", time.localtime(time.time())) +
time.strftime("%H:%M:%S", time.localtime(time.time()))
}
res = utils.add_by_data(ProjectInfo, project)
project = ProjectInfo.query.filter_by(project_name=project_name).first()
add_result(project.id, project.version_num)
return reply(success=res[0], message=res[1])
def login():
data = request.get_json()
user = UserInfo.query.filter_by(
user_name=data["user_name"]
).first()
if not user or user.password != data['password']:
return reply(
success=False,
message="username or password is wrong!"
)
login_user(user)
flash("login successfully!")
return reply(
success=True,
message="登陆成功",
)
def query_court_resource():
court_resource_id = utils.get_court_resource_id(request)
court_id = utils.get_court_id(request)
if court_resource_id is not None:
court_resources = CourtResource.query.order_by(
CourtResource.court_id
).filter_by(
id = court_resource_id,
record_status = const.record_normal
).all()
elif court_id is not None:
court_resources = CourtResource.query.order_by(
CourtResource.court_id
).filter_by(
court_id = court_id,
record_status = const.record_normal
).all()
else:
court_resources = CourtResource.query.order_by(
CourtResource.court_id
).filter_by(
record_status = const.record_normal
).all()
data = []
for court_resource in court_resources:
data.append(court_resource.to_json())
return reply(success=True, data=data, message='done', error_code=const.code_success)
def add_department():
form = AddDepartmentForm(request.form)
if not form.validate():
return reply(success=False, message='参数错误', error_code=const.code_param_err)
dept_exist = Department.query.filter_by(
dept_name=form.dept_name.data,
record_status=const.record_normal
).first()
if dept_exist:
return reply(success=False, message='该部门已存在', error_code=const.code_param_illegal)
department_data = {
'dept_name': form.dept_name.data,
'record_status': const.record_normal,
}
res = utils.add_by_data(Department, department_data)
return reply(success=res[0], message=res[1], error_code=res[2])
def court_type_query():
court_type = CourtType.query.order_by(CourtType.id).all()
data = []
for court in court_type:
data.append(court.to_json())
return reply(success=True,
data=data,
message='done',
error_code=const.code_success)
def period_delete():
cur_user = UserInfo.query.filter_by(
id=current_user.id, record_status=const.record_normal).first()
if not cur_user:
return reply(success=False,
message='内部出错，请联系管理员',
error_code=const.code_inner_err)
period_class_id = get_period_class_id(request)
period_class_data = PeriodClass.query.filter_by(
id=period_class_id, record_status=const.record_normal)
period_class_exist = period_class_data.first()
if not period_class_exist:
return reply(success=False,
message='找不该时间段类型',
error_code=const.code_param_illegal)
else:
res = delete_by_id(PeriodClass, period_class_id)
return reply(success=res[0], message=res[1], error_code=res[2])
def result():
project_id = request.form.get("project_id")
version_num = request.form.get("version_num")
flag = request.form.get('flag')
re = Result.query.filter_by(project_id=project_id,
version_num=version_num,
flag=flag).first()
if (re.available == '1'):
data = {
'Socket': re.socket,
'Process': re.process,
'Memory': re.memory,
'DB connection': re.db_connection,
'File handler': re.file_handler,
'Thread': re.thread
}
print(data)
return reply(success=True, data=data)
return reply(success=False)
def query_department():
departments = Department.query.order_by(
Department.dept_name
).filter_by(
record_status=const.record_normal
).all()
data = []
for department in departments:
data.append(department.to_json())
return reply(success=True, data=data, message='done', error_code=const.code_success)
def courtResource_occupied(id):
if current_user.user_type != const.user_type_admin:
return reply(success=False,
message='无权限',
error_code=const.code_not_permit)
court = Court.query.filter_by(id=id).first()
date_now = datetime.date.today()
dates = []
for i in range(1, court.order_days + 1):
date = (date_now + datetime.timedelta(days=i))
dates.append(date)
pattern = re.compile('(.*)_(.*)_(.*)')
cr_name = request.args.get('date_period_number')
target_date, target_period, target_number = re.findall(pattern, cr_name)[0]
target_date = (list(
filter(lambda x: x.strftime('%m.%d') == target_date, dates)))[0]
court_resource_query = CourtResource.query.filter_by(
date=target_date,
period_id=target_period,
court_number=target_number,
court_id=id)
court_resource = court_resource_query.first()
if court_resource and court_resource.occupied == False:
cr_data = {
'occupied': True,
}
schedule_query = Schedule.query.filter_by(court_id=id,
date=court_resource.date)
schedule = Schedule.query.filter_by(court_id=id,
date=court_resource.date).first()
if not schedule:
return reply(success=False, message="数据错误！", error_code=2)
schedule_date = {
'occupied_count': schedule.occupied_count + 1,
}
update_by_data(court_resource_query, cr_data, False)
res = update_by_data(schedule_query, schedule_date)
return reply(success=res[0], message=res[1], error_code=res[2])
return reply(success=True, message='', error_code=const.success)
def selectCourt():
courts = Court.query.all()
if not courts:
return reply(success=False, message='无任何场馆！', error_code=1)
gyms = [Gym.query.filter_by(id=court.gym_id).first() for court in courts]
if not gyms:
return reply(success=False, message='数据错误！', error_code=2)
sc = [{
'court_id': court.id,
'gym_name': gym.gym_name,
'court_name': court.court_name,
'court_type': court.court_type,
'court_fee': court.court_fee,
'gym_id': gym.id
} for court, gym in zip(courts, gyms)]
data = {'src': sc}
return reply(success=True, data=data, error_code='')
def sportsfield_delete():
cur_user = UserInfo.query.filter_by(
id=current_user.id, record_status=const.record_normal).first()
if not cur_user:
return reply(success=False,
message='内部出错，请联系管理员',
error_code=const.code_inner_err)
court_id = get_sportsfield_id(request)
if not court_id:
return reply(success=False,
message='未知运动场场地',
error_code=const.code_param_err)
court_exits = Court.query.filter_by(
id=court_id, record_status=const.record_normal).first()
if not court_exits:
return reply(success=False,
message='找不到该运动场地',
error_code=const.code_unknown_err)
res = delete_by_id(Court, court_id)
return reply(success=res[0], message=res[1], error_code=res[2])
def get_configuration():
project_id = request.form.get("project_id")
re = Configuration.query.filter_by(id=project_id).first()
data = {
'Socket': re.socket,
'Process': re.process,
'Memory': re.memory,
'DB connection': re.db_connection,
'File handler': re.file_handler,
'Thread': re.thread
}
return reply(success=True, data=data)
def sportsfield_edit():
form = EditSportFieldForm(request.form)
if not form.validate():
return param_error(form.errors)
court_rel = Court.query.filter_by(
id=form.id.data, #请求数据：场地id
record_status=const.record_normal)
court = court_rel.first()
if not court:
return reply(success=False,
message='找不该运动场',
error_code=const.code_param_illegal)
gym_id = court.gym_id
gym_rel = Gym.query.filter_by(id=gym_id,
record_status=const.record_normal).first()
cur_user = UserInfo.query.filter_by(
id=current_user.id, record_status=const.record_normal).first()
if cur_user.user_type > const.user_type_manage and cur_user.user_number != gym_rel.manager_number:
return reply(success=False,
message='无权限',
error_code=const.code_not_permit)
update_data = {}
if form.court_name.data and form.court_name.data != court.court_name:
update_data['court_name'] = form.court_name.data
if form.court_type.data and form.court_type.data != court.court_type:
update_data['court_type'] = form.court_type.data
if form.court_num.data and form.court_num.data != court.court_count:
update_data['court_count'] = form.court_num.data
if form.court_fee.data and form.court_fee.data != court.court_fee:
update_data['court_fee'] = form.court_fee.data
if form.order_days.data and form.order_days.data != court.order_days:
update_data['order_days'] = form.order_days.data
if form.court_description.data and form.court_description.data != court.description:
update_data['description'] = form.court_description.data
if form.period_class_id.data and form.period_class_id.data != court.period_class_id:
update_data['period_class_id'] = form.period_class_id.data
res = update_by_data(court_rel, update_data, True)
return reply(success=res[0], message=res[1], error_code=res[2])
def add_period_data():
form = AddPeriodData(request.form)
if not form.validate():
return reply(success=False,
message='参数错误',
error_code=const.code_param_err)
period_data_exist = PeriodData.query.filter_by(
period_class_id=form.period_class_id.data,
start_time=form.start_time.data,
end_time=form.end_time.data,
record_status=const.record_normal,
).first()
if period_data_exist:
return reply(success=False,
message='时间段数据已存在',
error_code=const.code_param_illegal)
period_data = {
'period_class_id': form.period_class_id.data,
'start_time': form.start_time.data,
'end_time': form.end_time.data,
}
res = utils.add_by_data(PeriodData, period_data)
return reply(success=res[0], message=res[1], error_code=res[2])
def query_period_data():
# period_id = utils.get_period_id(request)
period_class_id = utils.get_real_period_class_id(request)
if period_class_id is not None:
period_datas = PeriodData.query.order_by(
PeriodData.period_class_id).filter_by(
period_class_id=period_class_id,
record_status=const.record_normal).all()
period_types = PeriodClass.query.order_by(PeriodClass.id).filter_by(
id=period_class_id, record_status=const.record_normal).first()
if period_types:
period_class_data = period_types.to_json()
period_class_name = period_class_data['period_class_name']
period_class_description = period_class_data[
'period_class_description']
else:
period_class_name = ''
period_class_description = ''
else:
data = [{'period_class_name': '', 'period_class_description': ''}]
return reply(success=False,
data=data,
message='no period class id',
error_code=const.code_param_err)
data = []
for period_data in period_datas:
curDict = period_data.to_json()
curDict['start_time'] = curDict['start_time'].strftime(
'%Y-%m-%d %H:%M:%S')
curDict['end_time'] = curDict['end_time'].strftime('%Y-%m-%d %H:%M:%S')
curDict['period_class_name'] = period_class_name
curDict['period_class_description'] = period_class_description
data.append(curDict)
return reply(success=True,
data=data,
message='done',
error_code=const.code_success)
def add_court_resource():
form = AddCourtResource(request.form)
if not form.validate():
return reply(success=False, message='参数错误', error_code=const.code_param_err)
court_resource_exist = CourtResource.query.filter_by(
date = form.date.data,
period_id = form.period_id.data,
court_id = form.court_id.data,
court_number = form.court_number.data,
record_status = const.record_normal,
).first()
if court_resource_exist:
return reply(success=False, message='场地资源已存在', error_code=const.code_param_illegal)
court_resource = {
'date': form.date.data,
'period_id': form.period_id.data,
'court_id': form.court_id.data,
'court_number': form.court_number.data,
'occupied': form.occupied.data,
'max_order_count': form.max_order_count.data,
'order_count': form.order_count.data,
}
res = utils.add_by_data(CourtResource, court_resource)
return reply(success=res[0], message=res[1], error_code=res[2])
def period_add():
form = AddPeriodForm(request.form)
if not form.validate():
return param_error(form.errors)
cur_user = UserInfo.query.filter_by(
id=current_user.id, record_status=const.record_normal).first()
if not cur_user:
return reply(success=False,
message='内部出错，请联系管理员',
error_code=const.code_inner_err)
period_class_name = form.period_class_name.data
description = form.period_description.data
print(description)
if period_class_name:
period_class_data = {
"period_class_name": period_class_name,
"period_class_description": description
}
res = add_by_data(PeriodClass, period_class_data)
return reply(success=res[0], message=res[1], error_code=res[2])
else:
return reply(success=False,
message="period_class_name required",
error_code=const.code_param_err)
def query_name_by_id():
court_id = request.args.get('court_id', None)
gym_id = request.args.get('gym_id', None)
court = Court.query.filter_by(
id = court_id,
record_status = const.record_normal
).first()
gym = Gym.query.filter_by(
id = gym_id,
record_status = const.record_normal
).first()
data = {}
data["court_id"] = court_id
data["gym_id"] = gym_id
data["court_name"] = court.court_name
data["gym_name"] = gym.gym_name
return reply(success=True, data=data, message='done', error_code=const.code_success)
def sportsfield_define():
form = SportFieldDefineForm(request.form)
if not form.validate():
return param_error(form.errors)
gym_id = get_gym_id(request)
gym = Gym.query.filter_by(id=gym_id,
record_status=const.record_normal).first()
gym_name = gym.gym_name
location = gym.location
sportsfield = Court.query.filter_by(
gym_id=gym_id, record_status=const.record_normal).all()
reply_data = list(map(lambda x: transform(x), sportsfield))
for item in reply_data:
item['gym_name'] = gym_name
item['location'] = location
return reply(success=True,
data=reply_data,
message='done',
error_code=const.code_success)
def query_field_data():
courts = Court.query.filter_by(
record_status = const.record_normal
).all()
data = []
for court in courts:
ret = {}
ret["court_id"] = court.id
ret["gym_id"] = court.gym_id
ret["court_name"] = court.court_name
ret["period_class_id"] = court.period_class_id
ret["order_days"] = court.order_days
gym = Gym.query.filter_by(
id = ret["gym_id"],
record_status = const.record_normal
).first()
ret["gym_name"] = gym.gym_name
period_class = PeriodClass.query.filter_by(
id = ret["period_class_id"],
record_status = const.record_normal
).first()
ret["period_class_name"] = period_class.period_class_name
data.append(ret)
return reply(success=True, data=data, message='done', error_code=const.code_success)
def update_project():
project_id = request.form.get("project_id")
project_name = request.form.get("project_name")
description = request.form.get("description")
release_desc = request.form.get("release_desc")
types = request.form.get("types")
flag = int(request.form.get("flag"))
project_info = ProjectInfo.query.filter_by(id=project_id).first()
project = {
"project_name":
project_name,
"description":
description,
"types":
types,
"date":
time.strftime("%Y-%m-%d ", time.localtime(time.time())) +
time.strftime("%H:%M:%S", time.localtime(time.time()))
}
if flag == 1: # create a new version
program = request.files["program"]
program.save(osp.join("program", program.filename))
project["id"] = project_info.id
project["program_file"] = program.filename
project['release_desc'] = release_desc
project['version_num'] = project_info.version_num + 1
project['user_name'] = project_info.user_name
res = utils.add_by_data(ProjectInfo, project)
add_result(project_info.id, project_info.version_num + 1)
else:
res = utils.update_by_data(project_info, project)
return reply(success=res[0], message=res[1])
def period_query():
# cur_user = UserInfo.query.filter_by(
# id=current_user.id,
# record_status = const.record_normal
# ).first()
# if not cur_user:
# return reply(success=False, message='内部出错，请联系管理员', error_code=const.code_inner_err)
# if cur_user.user_type > const.user_type_admin:
# return reply(success=False, message='无权限', error_code=const.code_not_permit)
period_class_id = get_real_period_class_id(request)
if period_class_id is not None:
period_types = PeriodClass.query.order_by(PeriodClass.id).filter_by(
id=period_class_id, record_status=const.record_normal).all()
else:
period_types = PeriodClass.query.order_by(
PeriodClass.id).filter_by(record_status=const.record_normal).all()
data = []
for item in period_types:
data.append(item.to_json())
return reply(success=True,
data=data,
message='done',
error_code=const.code_success)
def login_out():
if current_user.is_authenticated:
auth.login_out()
return reply(success=True, )
