def add_result(project_id, version_num):
static_result = {
"project_id": project_id,
"version_num": version_num,
"flag": 0,
"available": 0
}
dynamic_result = {
"project_id": project_id,
"version_num": version_num,
"flag": 1,
"available": 0
}
utils.add_by_data(Result, static_result)
utils.add_by_data(Result, dynamic_result)
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 add_device():
valid, form = parsing_form('addDeviceForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
if utils.is_code_exist(Device, form['code'])[0]:
return reply(success=False,
message='该设备编码已存在',
error_code=const.PARAM_ILLEGAL)
if not utils.is_id_exist(Department, form['department_id'])[0]:
return reply(success=False,
message='该部门不存在',
error_code=const.PARAM_ILLEGAL)
if not utils.is_id_exist(Manufacturer, form['manufacturer_id'])[0]:
return reply(success=False,
message='该生产厂家不存在',
error_code=const.PARAM_ILLEGAL)
device_data = {
'code': form['code'],
'name': form['name'],
'model': form['model'],
'brand': form['brand'],
'tag_code': form['tag_code'],
'description': form['description'],
'status': const.DEVICE_RETURNED,
'manufacturer_date': form['manufacturer_date'],
'manufacturer_id': form['manufacturer_id'],
'department_id': form['department_id'],
'record_status': const.RECORD_NORMAL,
}
res = utils.add_by_data(Device, device_data)
return reply(success=res[0], message=res[1], error_code=res[2])
def add_achievement():
valid, form = parsing_form('addAchievementForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
res_device = utils.is_code_exist(Device, form['device_code'])
if not res_device[0]:
return reply(success=False,
message='设备不存在',
error_code=const.PARAM_ILLEGAL)
if not utils.is_code_exist(Member, form['member_code'])[0]:
return reply(success=False,
message='成员不存在',
error_code=const.PARAM_ILLEGAL)
device = res_device[1].first()
device_achievement_data = {
'device_code': form['device_code'],
'member_code': form['member_code'],
'department_id': device.department_id,
'manufacturer_date': form['manufacturer_date'],
'achievement_description': form['achievement_description'],
'patent_description': form['patent_description'],
'paper_description': form['paper_description'],
'competition_description': form['competition_description'],
'achievement_remark': form['achievement_remark'],
'record_status': const.RECORD_NORMAL,
}
res = utils.add_by_data(Achievement, device_achievement_data)
return reply(success=res[0], message=res[1], error_code=res[2])
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 add_manufacturer():
valid, form = parsing_form('addManufacturerForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
if utils.is_name_exist(Manufacturer, form['name'])[0]:
return reply(success=False, message='该生产厂家已存在', error_code=const.PARAM_ILLEGAL)
manufacturer_data = {
'name': form['name'],
'record_status': const.RECORD_NORMAL,
}
res = utils.add_by_data(Manufacturer, manufacturer_data)
return reply(success=res[0], message=res[1], error_code=res[2])
def add_department():
valid, form = parsing_form('addDepartmentForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
if utils.is_code_exist(Department, form['code'])[0]:
return reply(success=False,
message='该部门已存在',
error_code=const.PARAM_ILLEGAL)
department_data = {
'code': form['code'],
'name': form['name'],
'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 register():
data = request.get_json()
user_exist = UserInfo.query.filter_by(user_name=data["user_name"]).first()
if user_exist:
return reply(success=False, message='user exists!')
user_exist = UserInfo.query.filter_by(email=data["email"]).first()
if user_exist:
return reply(success=False, message='email has been registered!')
user_data = {
'user_name': data["user_name"],
'email': data["email"],
'password': data["password"],
}
res = utils.add_by_data(UserInfo, user_data)
return reply(success=res[0], message=res[1])
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 rent_device():
valid, form = parsing_form('rentDeviceForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
res_device = utils.is_code_exist(Device, form['device_code'])
if not res_device[0]:
return reply(success=False, message='该设备不存在', error_code=const.PARAM_ILLEGAL)
device = res_device[1].first()
if device.status != const.DEVICE_RETURNED:
return reply(success=False, message='该设备已被借出', error_code=const.PARAM_ILLEGAL)
res_member = utils.is_code_exist(Member, form['borrower_member_code'])
if not res_member[0]:
return reply(success=False, message='该成员不存在', error_code=const.PARAM_ILLEGAL)
member = res_member[1].first()
update_info = {
'status': const.DEVICE_RENTED,
}
if not utils.update_by_data(res_device[1], update_info, False)[0]:
return reply(success=False, message='设备状态修改失败', error_code=const.UNKNOWN_ERR)
device_rent_data = {
'device_code': form['device_code'],
'device_department_id': device.department_id,
'status': const.DEVICE_RENTED,
'borrower_member_code': form['borrower_member_code'],
'borrower_department_id': member.department_id,
'borrow_date': form['borrow_date'],
'borrow_remark': form['borrow_remark'],
'expect_return_date': form['expect_return_date'],
# default
'returner_member_code': '',
'returner_department_id': 0,
'real_return_date': form['expect_return_date'],
'return_remark': '',
'record_status': const.RECORD_NORMAL,
}
res = utils.add_by_data(DeviceRent, device_rent_data)
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 add_member():
valid, form = parsing_form('addMemberForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
if utils.is_code_exist(Member, form['code'])[0]:
return reply(success=False,
message='该成员编码已存在',
error_code=const.PARAM_ILLEGAL)
if not utils.is_id_exist(Department, form['department_id'])[0]:
return reply(success=False,
message='该部门不存在',
error_code=const.PARAM_ILLEGAL)
member_data = {
'code': form['code'],
'name': form['name'],
'department_id': form['department_id'],
'record_status': const.RECORD_NORMAL,
}
res = utils.add_by_data(Member, member_data)
return reply(success=res[0], message=res[1], error_code=res[2])
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 register():
form = RegisterForm(request.form)
if not form.validate():
return param_error(form.errors)
user_exist = UserInfo.query.filter_by(
user_alias=form.user_alias.data,
record_status=const.record_normal).first()
if user_exist:
return reply(success=False,
message='用户别名已存在',
error_code=const.code_param_illegal)
user_exist = UserInfo.query.filter_by(
user_number=form.user_number.data,
record_status=const.record_normal).first()
if user_exist:
return reply(success=False,
message='职工号已存在',
error_code=const.code_param_illegal)
dept_exist = Department.query.filter_by(
id=form.dept_id.data, record_status=const.record_normal).first()
if not dept_exist:
return reply(success=False,
message='部门不存在',
error_code=const.code_param_illegal)
user_data = {
'user_name': form.user_name.data,
'user_alias': form.user_alias.data,
'user_number': form.user_number.data,
'dept_id': form.dept_id.data,
'password': form.password.data,
'user_type': const.user_type_normal,
'account_balance': 0,
'disabled': const.user_disabled_false,
}
res = utils.add_by_data(UserInfo, user_data)
return reply(success=res[0], message=res[1], error_code=res[2])
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 order_cancel_button():
# Method: post
form = CancelOrder(request.form)
if not form.validate():
return param_error(form.errors())
user_order = CourtOrder.query.filter_by(
id=form.cancel_order_id.data).first() # 要取消的用户订单表单
if not user_order:
return reply(success=False,
message='There is no such order!',
error_code=1)
is_canceled = user_order.is_canceled
if is_canceled:
return reply(success=False,
message="This order has been canceled!",
error_code=2)
money_paid = user_order.amount # 已经付款的金额
if money_paid == 0: # 还未付款，直接取消即可，不用返回钱款
user_order.is_canceled = True # 登记取消
user_order.cancel_time = datetime.now() # 登记取消时间
# 场地资源 + 1
court_resource = CourtResource.query.filter_by(
id=user_order.resource_id)
if not court_resource:
return reply(success=False,
message='Failed to cancel!',
error_code=3)
court_resource.order_count += 1
# 记账
user_id = user_order.user_id
account_data = {
'user_id': user_id,
'order_id': form.order_id.data,
'account_summary': '退款',
'account_time': datetime.now(),
'amount': 0
}
res = add_by_data(Account, account_data) # 上面修改一起commit
if not res[0]:
return reply(success=False,
message='Failed to cancel!',
error_code=3)
return reply(success=res[0],
message='Order canceled successfully!',
error_code=const.code_success)
elif money_paid > 0: # 已经付过款，要返回钱款
user_order.is_canceled = True # 记录取消
user_order.cancel_time = datetime.now() # 记录取消时间
# 获取订单单价
resource_id = user_order.resource_id
court_resource = CourtResource.query.filter_by(id=resource_id).first()
if not court_resource:
return reply(success=False,
message='Failed to cancel!',
error_code=3)
court_id = court_resource.court_id
court_info = Court.query.filter_by(id=court_id).first()
if not court_info:
return reply(success=False,
message='Failed to cancel!',
error_code=3)
order_price = court_info.court_fee
# 返回钱款给用户
user_id = user_order.user_id
user_info = UserInfo.query.filter_by(id=user_id).first()
if not user_info:
return reply(success=False,
message='Failed to cancel!',
error_code=3)
user_info.account_balance = user_info.account_balance + order_price
# 场地资源 + 1
court_resource.order_count += 1
# 记账
account_data = {
'user_id': user_id,
'order_id': form.cancel_order_id.data,
'account_summary': '退款',
'account_time': datetime.now(),
'amount': order_price
}
res = add_by_data(Account, account_data) # 前面的修改一起commit
if not res[0]:
return reply(success=False,
message='Failed to cancel!',
error_code=3)
return reply(success=res[0],
message='Order canceled successfully!',
error_code=const.code_success)
def pay_money():
# Method: Post
# The parameter received from the user's form is order's id
form = PayOrder(request.form)
if not form.validate():
return param_error(form.errors())
user_order = CourtOrder.query.filter_by(id=form.order_id.data).first()
if not user_order:
return reply(success=False,
message='There is no such order!',
error_code=1)
# line 21-31 查找订单对应的场地的表，查出单价
resource_id = user_order.resource_id
court_resource = CourtResource.query.filter_by(id=resource_id).first()
if not court_resource:
return reply(success=False, message='Failed payment!', error_code=4)
if court_resource.is_canceled == 1:
return reply(success=False,
message='This order has been canceled',
error_code=5)
court_id = court_resource.court_id
court_info = Court.query.filter_by(id=court_id).first()
if not court_info:
reply(success=False, message='Failed payment', error_code=4)
order_price = court_info.court_fee
paid = user_order.amount # 该订单已经付了多少钱
# If the order has been paid, then false is returned
if paid > 0:
return reply(success=False,
message='This order has been paid!',
error_code=2)
user_id = user_order.user_id # 该订单所属用户的id
user_info = UserInfo.query.filter_by(id=user_id).first()
if not user_info:
reply(success=False, message='Failed payment', error_code=4)
left_balance = user_info.account_balance # 用户的当前余额
if order_price > left_balance:
return reply(success=False,
message="Insufficient remaining balance!",
error_code=3)
# 下面进行付款并修改数据库中相应的表单
# 1. 修改user_order
'''
order_update = {
'pay_time': datetime.now(),
'amount': order_price
}
user_order = CourtOrder.query.filter_by(
id=form.order_id.data
)
user_order.update(**order_update) # update 唔可以用，唔知点解, update要query对象才能用，加了first之后不能用
'''
user_order.pay_time = datetime.now()
user_order.amount = order_price
# 2. 修改user_info中的用户余额
user_info.account_balance = left_balance - order_price
# 3、记账，修改Account表单
account_data = {
'user_id': user_id,
'order_id': form.order_id.data,
'account_summary': '扣款',
'account_time': datetime.now(),
'amount': order_price
}
res = add_by_data(Account, account_data) # 前面的修改在add_by_data 这里一同commit了
return reply(success=res[0], message=res[1], error_code=res[2])
def order_submit(id):
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 = []
for i in range(1, court.order_days + 1):
date = (date_now + datetime.timedelta(days=i))
dates.append(date)
cr_name = request.args.get('date_period_number')
pattern = re.compile('(.*)_(.*)_(.*)')
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 not court_resource:
return reply(success=False, message="无对应场地资源！", error_code=4)
if court_resource.order_count < court_resource.max_order_count and not court_resource.occupied:
cr_data = {
'order_count': court_resource.order_count + 1,
}
schedule_query = Schedule.query.filter_by(court_id=id,
date=court_resource.date)
schedule = schedule_query.first()
if not schedule:
return reply(success=False, message="数据错误！", error_code=5)
schedule_date = {
'order_count': schedule.order_count + 1,
}
dt = datetime.datetime.today()
if dt.microsecond >= 500000:
dt = dt + datetime.timedelta(seconds=1)
dt = dt - datetime.timedelta(microseconds=dt.microsecond)
co_data = {
'id': None,
'user_id': current_user.id,
'order_time': dt,
'resource_id': court_resource.id,
'pay_time': None,
'amount': 0,
'is_acked': False,
'ack_time': None,
'is_canceled': False,
'cancel_time': None,
'is_used': False
}
update_by_data(court_resource_query, cr_data, False)
update_by_data(schedule_query, schedule_date, False)
res = add_by_data(CourtOrder, co_data)
if res[0] is True:
order_id = CourtOrder.query.filter_by(user_id=current_user.id, order_time=dt, resource_id=court_resource.id, amount=0, \
is_acked=False, is_canceled=False, is_used=False).first()
if not order_id:
return reply(success=False, message="数据错误！", error_code=8)
order_id = order_id.id
return reply(success=True,
data={'order_id': order_id},
error_code=0)
return reply(success=res[0], message=res[1], error_code=res[2])
elif court_resource.order_count >= court_resource.max_order_count:
return reply(success=False, message="当前场地预订剩余量为0！", error_code=6)
elif court_resource.occupied:
return reply(success=False, message="当前场地已占用！", error_code=7)
