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 delete_department():
valid, form = parsing_form('deleteByIdForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
res = utils.delete_by_id(Department, form['id'])
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 query_member():
page_info = utils.get_page_info(request)
current_page = page_info[0]
page_size = page_info[1]
valid, form = parsing_form('queryMemberForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
members = Member.query.filter_by()
query_dict = dict()
if form['id']:
query_dict['id'] = form['id']
if form['code']:
query_dict['code'] = form.code.data
if form['name']:
query_dict['name'] = form.name.data
if query_dict:
members = members.filter_by(**query_dict)
members = members.filter_by(record_status=const.RECORD_NORMAL)
total_count = members.count()
members = members.paginate(current_page, page_size, False).items
data = []
for member in members:
data.append(member.to_json())
return query_reply(success=True,
data=data,
paging={
'current': current_page,
'pages': int(total_count / page_size + 1),
'records': total_count,
},
message='done',
error_code=const.CODE_SUCCESS)
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 query_achievement():
page_info = utils.get_page_info(request)
current_page = page_info[0]
page_size = page_info[1]
valid, form = parsing_form('queryAchievementForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
achievement_query = dict()
if form['device_code']:
achievement_query['device_code'] = form['device_code']
if form['member_code']:
achievement_query['member_code'] = form['member_code']
if form['department_id']:
achievement_query['department_id'] = form['department_id']
achievements = Achievement.query.filter_by()
if achievement_query:
achievements = achievements.filter_by(**achievement_query)
device_query = dict()
if form['device_code']:
device_query['code'] = form['device_code']
if form['device_name']:
device_query['name'] = form['device_name']
if form['model']:
device_query['model'] = form['model']
if form['brand']:
device_query['brand'] = form['brand']
if form['tag_code']:
device_query['tag_code'] = form['tag_code']
devices = Device.query.filter_by()
if device_query:
devices = devices.filter_by(**device_query)
achievements = achievements.filter(
Achievement.device_code.in_(map(lambda x: x.code, devices)))
if form['manufacturer_date']:
achievements = achievements.filter(
db.cast(Achievement.manufacturer_date, db.DATE) ==
form['manufacturer_date'])
total_count = achievements.count()
achievements = achievements.paginate(current_page, page_size, False).items
data = map(lambda x: transform(x), achievements)
data = list(data)
return query_reply(success=True,
data=data,
paging={
'current': current_page,
'pages': int(total_count / page_size + 1),
'records': total_count,
},
message='done',
error_code=const.CODE_SUCCESS)
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 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 query_device():
page_info = utils.get_page_info(request)
current_page = page_info[0]
page_size = page_info[1]
valid, form = parsing_form('queryDeviceForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
device_query = dict()
if form['code']:
device_query['code'] = form['code']
if form['name']:
device_query['name'] = form['name']
if form['model']:
device_query['model'] = form['model']
if form['brand']:
device_query['brand'] = form['brand']
if form['tag_code']:
device_query['tag_code'] = form['tag_code']
if form['status']:
device_query['status'] = form['status']
if form['manufacturer_id']:
device_query['manufacturer_id'] = form['manufacturer_id']
if form['department_id']:
device_query['department_id'] = form['department_id']
devices = Device.query.filter_by()
if device_query:
device_query['record_status'] = const.RECORD_NORMAL
devices = devices.filter_by(**device_query)
if form['manufacturer_date']:
devices = devices.filter(
db.cast(Device.manufacturer_date, db.DATE) ==
form['manufacturer_date'])
total_count = devices.count()
devices = devices.paginate(current_page, page_size, False).items
data = map(lambda x: transform(x), devices)
data = list(data)
return query_reply(success=True,
data=data,
paging={
'current': current_page,
'pages': int(total_count / page_size + 1),
'records': total_count,
},
message='done',
error_code=const.CODE_SUCCESS)
def return_device():
valid, form = parsing_form('returnDeviceForm')
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_RENTED:
return reply(success=False, message='该设备未被借出', error_code=const.PARAM_ILLEGAL)
device_rented = DeviceRent.query.filter_by(
device_code=form['device_code'],
status=const.DEVICE_RENTED,
record_status=const.RECORD_NORMAL
)
cnt = device_rented.count()
if cnt < 1:
return reply(success=False, message='无此设备正在外借记录', error_code=const.UNKNOWN_ERR)
if cnt > 1:
return reply(success=False, message='内部数据错误，请联系管理员', error_code=const.UNKNOWN_ERR)
res_member = utils.is_code_exist(Member, form['returner_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_RETURNED,
}
if not utils.update_by_data(res_device[1], update_info, False)[0]:
return reply(success=False, message='设备状态修改失败', error_code=const.UNKNOWN_ERR)
device_return_data = {
'status': const.DEVICE_RETURNED,
'returner_member_code': form['returner_member_code'],
'returner_department_id': member.department_id,
'real_return_date': form['return_date'],
'return_remark': form['return_remark'],
}
res = utils.update_by_data(device_rented, device_return_data, True)
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_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 query_rent_device():
page_info = utils.get_page_info(request)
current_page = page_info[0]
page_size = page_info[1]
valid, form = parsing_form('queryDeviceLendForm')
if not valid:
return reply(success=False, message='参数错误', error_code=const.PARAM_ERR)
rent_query = dict()
if form['device_code']:
rent_query['device_code'] = form['device_code']
if form['status']:
rent_query['status'] = form['status']
if form['department_id']:
rent_query['device_department_id'] = form['department_id']
if form['borrower_member_code']:
rent_query['borrower_member_code'] = form['borrower_member_code']
if form['borrower_department_id']:
rent_query['borrower_department_id'] = form['borrower_department_id']
if form['returner_member_code']:
rent_query['returner_member_code'] = form['returner_member_code']
if form['returner_department_id']:
rent_query['returner_department_id'] = form['returner_department_id']
device_rents = DeviceRent.query.filter_by()
if rent_query:
device_rents = device_rents.filter_by(
**rent_query
)
device_query = dict()
if form['device_name']:
device_query['device_name'] = form['device_name']
if form['model']:
device_query['model'] = form['model']
if form['brand']:
device_query['brand'] = form['brand']
if form['tag_code']:
device_query['tag_code'] = form['tag_code']
if device_query:
devices = Device.filter_by(
**device_query
)
device_rents = device_rents.filter(
DeviceRent.device_code.in_(
map(lambda x: x.device_code, devices)
)
)
if form['borrow_date']:
device_rents = device_rents.filter(
db.cast(DeviceRent.borrow_date, db.DATE) == form['borrow_date'])
if form['real_return_date']:
device_rents = device_rents.filter(
db.cast(DeviceRent.return_date, db.DATE) == form['real_return_date'])
if form['expect_return_date']:
device_rents = device_rents.filter(
db.cast(DeviceRent.expect_return_date, db.DATE) == form['expect_return_date'])
total_count = device_rents.count()
device_rents = device_rents.paginate(current_page, page_size, False).items
data = map(lambda x: transform(x), device_rents)
data = list(data)
return query_reply(success=True,
data=data,
paging={
'current': current_page,
'pages': int(total_count / page_size + 1),
'records': total_count,
},
message='done', error_code=const.CODE_SUCCESS)