def set_vip_price(self):
"""设置会员价格"""
data = parameter_required(('VIP',))
csd = Setting.query.filter(Setting.isdelete == 0, Setting.STname == "VIP").first()
csd_dict = {
"STname": "VIP",
"STvalue": data.get("VIP"),
"STtype": 5
}
with db.auto_commit():
if not csd:
csd_dict["STid"] = str(uuid.uuid1())
csd_instance = Setting.create(csd_dict)
msg = "创建会员价格成功"
else:
csd_instance = Setting.query.filter_by_(STid=csd.STid).first_('未找到会员价格')
csd_instance.update(csd_dict, null='not')
msg = "更新会员价格成功"
db.session.add(csd_instance)
return Success(message=msg)
def update_pointtask(self):
"""更新任务积分以及次数"""
# 后台更新次数以及积分数，负表示仅限次数，0表示无限次，正表示每日可完成次数
if not (is_admin() or is_hign_level_admin()):
return AuthorityError()
data = parameter_required(('ptid', 'ptnumber', 'pttime', 'pticon'))
if not data.get('ptnumber'):
data['ptnumber'] = 0
if not data.get('pttime'):
data['pttime'] = 0
pt_dict = {
"PTnumber": data.get('ptnumber'),
"PTtime": data.get('pttime'),
"PTicon": data.get('pticon')
}
pt_instance = PointTask.query.filter(PointTask.PTid == data.get('ptid')).first_("未找到该任务")
with db.auto_commit():
pt_instance.update(pt_dict, null='not')
db.session.add(pt_instance)
return Success(message="更新任务成功")
def update_admin_password(self):
"""更新管理员密码"""
data = parameter_required(('password_old', 'password_new', 'password_repeat'))
# 校检两次密码是否相同
pwd_new = data.get('password_new')
pwd_old = data.get('password_old')
pwd_repeat = data.get('password_repeat')
if pwd_new != pwd_repeat:
raise ParamsError('两次输入的密码不同')
token = token_to_user_(request.args.get("token"))
if int(request.args.get('adtype')) == 1:
ad = Admin.query.filter(Admin.isdelete == 0, Admin.ADid == token.id).first()
adpassword = ad.ADpassword
ad_dict = {
"ADpassword": generate_password_hash(pwd_new)
}
elif int(request.args.get('adtype')) == 2:
ad = Doctor.query.filter(Doctor.isdelete == 0, Doctor.DOid == token.id).first()
print(ad)
adpassword = ad.DOpassword
ad_dict = {
"DOpassword": generate_password_hash(pwd_new)
}
else:
ad = None
adpassword = None
ad_dict = {}
if ad:
with db.auto_commit():
if check_password_hash(adpassword, pwd_old):
print(1)
self.__check_password(pwd_new)
ad.ADpassword = generate_password_hash(pwd_new)
ad.update(ad_dict, null='not')
else:
raise ParamsError('旧密码有误')
db.session.add(ad)
return Success('更新密码成功')
raise AuthorityError('账号已被回收')
def batch_operation(self):
data = parameter_required('prstatus', )
try:
prstatus = ProductStatus(int(str(data.get('prstatus', 0)))).value
except:
raise ParamsError('状态参数异常')
pridlist = data.get('pridlist', [])
if not isinstance(pridlist, list):
raise ParamsError('商品列表格式不对')
with db.auto_commit():
exec_sql = Products.query.filter(Products.PRid.in_(pridlist),
Products.isdelete == 0)
if prstatus == ProductStatus.delete.value:
# 执行批量删除
exec_sql.delete_(synchronize_session=False)
return Success('删除成功')
exec_sql.update({'PRstatus': prstatus}, synchronize_session=False)
return Success('{}成功'.format(ProductStatus(prstatus).zh_value))
def change_consultation_status(conid):
current_app.logger.info(">>> 更改会诊状态 conid:{} <<<".format(conid))
try:
consultation = Consultation.query.filter(
Consultation.isdelete == false(),
Consultation.CONid == conid).first()
if not consultation:
current_app.logger.error('conid: {} 不存在'.format(conid))
return
if consultation.CONstatus != ConsultationStatus.ready.value:
current_app.logger.error('状态不正确, CONstatus: {}'.format(
consultation.CONstatus))
return
with db.auto_commit():
consultation.update({'CONstatus': ConsultationStatus.finish.value})
current_app.logger.info('CONstatus: 0 --> 2')
conn.delete('change_consultation{}'.format(conid))
except Exception as e:
current_app.logger.error('Error: {}'.format(e))
finally:
current_app.logger.info(">>> 更改会诊状态任务结束 coid:{} <<<".format(conid))
def _over_ordermain(self, omid):
om = OrderMain.query.filter(
OrderMain.OMid == omid,
OrderMain.OMstatus == OrderMainStatus.ready.value,
OrderMain.isdelete == 0).first()
if not om:
current_app.logger.error('完成订单有误，订单ID不存在')
return
# 完成订单
with db.auto_commit():
omtype = om.OMtype
if int(omtype) == OrderMainType.product.value and int(
om.PRtype) == ProductType.package.value:
# 课时添加 - 积分商城
omsmsum = int(om.SMnum) * int(om.OMnum) # 订单总课时
classes = json.loads(om.PRcontent)
if not classes:
current_app.logger.error('课时信息录入异常 omid = {}'.format(omid))
return
self._increase_uhnum(om.USid, classes.get('CLid'), omsmsum)
if int(omtype) == OrderMainType.product.value and int(
om.PRtype) == ProductType.coupon.value:
# 优惠券变为可用
CouponUser.query.filter(
CouponUser.OMid == omid, CouponUser.isdelete == 0).update(
{'UCalreadyuse': CouponUserStatus.not_use.value},
synchronize_session=False)
if int(omtype) == OrderMainType.setmeal.value:
# 课时添加 - 课时套餐
omsmsum = int(om.SMnum) * int(om.OMnum)
self._increase_uhnum(om.USid, om.CLid, omsmsum)
# 积分任务添加 todo 购物积分增加待确认
current_app.logger.info('get omtype is {}'.format(omtype))
if int(omtype) == OrderMainType.product.value:
from .CConfig import CConfig
CConfig()._judge_point(PointTaskType.buy_product.value, 1, om.USid)
def get_wxac(self):
with db.auto_commit():
if not self.user.USwxac:
wxacpath = self.wxacode_unlimit(self.usid)
self.user.USwxac = wxacpath
else:
wxacpath = self.user.USwxac
wxac = os.path.join(current_app.config['BASEDIR'], wxacpath[1:])
if os.path.isfile(wxac):
return wxac
headurl = ALIOSS_ENDPOINT + self.user.USwxac
try:
data = requests.get(headurl)
with open(wxac, 'wb') as head:
head.write(data.content)
return wxac
except Exception as e:
current_app.logger.error(
'get avatar error usid = {} exception = {}'.format(
self.usid, e))
return ''
def _wallet_trade_setmeal(self, user, truemount, omid):
"""余额支付购买课时"""
# 增加记录
with db.auto_commit():
wr = WalletRecord.create({
'WRid': str(uuid.uuid1()),
'USid': user.USid,
'WRcash': truemount,
'WRtype': WalletRecordType.trade.value,
'ContentId': omid,
})
db.session.add(wr)
# 扣除金额
user.USbalance = user.USbalance - truemount
db.session.add(user)
om = OrderMain.query.filter(
OrderMain.isdelete == 0, OrderMain.OMid == omid,
OrderMain.OMstatus == OrderMainStatus.wait_pay.value).first()
if not om:
current_app.logger.error(f'订单状态错误, 未找到 omid: {omid}')
return
om.OMstatus = OrderMainStatus.ready.value
self._over_ordermain(omid)
def get_point(self):
"""领取积分"""
# 前台领取积分，基于ptid查找uitrue=0且uiaction=pttype的第一条数据，更新uitrue字段
data = parameter_required(('ptid', ))
args = request.args.to_dict()
user = token_to_user_(args['token'])
pointtask = PointTask.query.filter(PointTask.isdelete == 0,
PointTask.PTid == data.get('ptid')).first_("未找到该任务")
pttype = pointtask.PTtype
userintegral = UserIntegral.query.filter(UserIntegral.isdelete == 0, UserIntegral.USid == user.id,
UserIntegral.UItype == 1, UserIntegral.UItrue == 0,
UserIntegral.UIaction == pttype)\
.first_("无可领取积分")
with db.auto_commit():
ui_instance = UserIntegral.query.filter(UserIntegral.UIid == userintegral.UIid).first()
ui_instance.update({"UItrue": 1})
us_instance = User.query.filter(User.USid == user.id).first()
usintegral = int(us_instance.USintegral or 0) + int(pointtask.PTnumber or 0)
us_instance.update({"USintegral": usintegral})
db.session.add(ui_instance)
db.session.add(us_instance)
return Success(message="领取成功")
def shorten_parameters(raw, usid, raw_name):
"""
缩短分享参数
:param raw: 要分享的参数
:param usid: 用户id
:param raw_name: 分享参数名
:return: 缩短后的参数
"""
spsid = db.session.query(SharingParameters.SPSid).filter(
SharingParameters.SPScontent == raw,
SharingParameters.USid == usid,
SharingParameters.SPSname == raw_name).scalar()
current_app.logger.info('exist spsid : {}'.format(spsid))
if not spsid:
with db.auto_commit():
sps = SharingParameters.create({
'USid': usid,
'SPScontent': raw,
'SPSname': raw_name
})
db.session.add(sps)
spsid = sps.SPSid
return spsid
def add_admin(self):
"""超级管理员添加普通管理"""
if not is_hign_level_admin():
return AuthorityError()
data = parameter_required(('adname',))
adid = str(uuid.uuid1())
adname = data.get('adname')
adlevel = 2
# 账户名校验
self.__check_adname(adname)
# 创建管理员
with db.auto_commit():
adinstance = Admin.create({
'ADid': adid,
'ADname': adname,
"ADtelphone": "",
'ADpassword': generate_password_hash("123456"),
'ADheader': "",
'ADlevel': adlevel,
'ADstatus': 0,
})
db.session.add(adinstance)
# 创建管理员变更记录
an_instance = AdminActions.create({
'AAid': str(uuid.uuid1()),
'ADid': "1",
"AAaction": 1,
"AAmodel": "Admin",
'AAdetail': str(data)
})
db.session.add(an_instance)
return Success('创建管理员成功')
def sign_up(self):
"""用户报名"""
if not is_user():
raise TokenError
data = parameter_required('acid')
usid = getattr(request, 'user').id
user = User.query.filter(User.isdelete == false(),
User.USid == usid).first_('请重新登录')
if not user.UStelphone:
raise StatusError("请先在 '我的 - 我的家人' 中完善本人信息")
activity = Activity.query.filter(
Activity.isdelete == false(),
Activity.ACstatus == ActivityStatus.ready.value,
Activity.ACstartTime >= datetime.now(),
Activity.ACid == data.get('acid')).first_('活动已结束或不存在')
if self._ua_filter(
[UserActivity.USid == usid,
UserActivity.ACid == activity.ACid]).first():
raise StatusError('您已报名过该活动')
if self._query_activity_remain_people(activity) <= 0:
raise StatusError('该活动报名人数已满，请期待下次活动')
with db.auto_commit():
ua = UserActivity.create({
'UAid': str(uuid.uuid1()),
'USid': usid,
'ACid': activity.ACid,
'UAstatus': UserActivityStatus.ready.value
})
db.session.add(ua)
# 活动报名 积分任务
from .CConfig import CConfig
from ..config.enums import PointTaskType
CConfig()._judge_point(PointTaskType.make_activity.value, 1, user.USid)
return Success('报名成功', data={'uaid': ua.UAid})
def add_register(self):
data = parameter_required({'deid': '科室', 'redate': '日期', 'reamorpm': '上午或下午', 'faid': '就诊人'})
usid = getattr(request, 'user').id
deid, redate, faid, reamorpm = data.get('deid'), data.get('redate'), data.get('faid'), data.get('reamorpm')
reremarks = data.get('reremarks')
# 日期校验
redate = self._check_time(redate)
# 上午下午校验
try:
reamorpm = RegisterAmOrPm(int(str(reamorpm))).value
except:
reamorpm = 0
# 就诊人信息校验
family = Family.query.filter(
Family.USid == usid, Family.FAid == faid, Family.isdelete == 0).first_('就诊人信息已删除')
# 科室信息校验
dep = Departments.query.filter(Departments.isdelete == 0, Departments.DEid == deid).first_('科室不存在')
with db.auto_commit():
register = Register.create({
'REid': str(uuid.uuid1()),
'DEid': deid,
'USid': usid,
'FAid': faid,
'REdate': redate,
'REamOrPm': reamorpm,
'REremarks': reremarks
})
current_app.logger.info('创建挂号 科室 {} 就诊人 {}'.format(dep.DEname, family.FAname))
db.session.add(register)
# 预约挂号 积分任务
from .CConfig import CConfig
CConfig()._judge_point(PointTaskType.register.value, 1, usid)
return Success('预约成功{}，排队中'.format(dep.DEname))
def set_evaluationpoint(self):
"""设置分数区间"""
data = parameter_required((
'evid', 'epstart', 'epend',
'epanswer') if not request.json.get('delete') else ('epid', ))
epid = data.get("epid")
if not is_admin():
return AuthorityError()
if data.get('epstart') and data.get('epend'):
epstart = Decimal(str(data.get('epstart') or 0))
epend = Decimal(str(data.get('epend') or 0))
if epstart >= epend:
return PointError("区间大小设置错误")
else:
epstart = 0
epend = 0
epsharelevel = data.get('epsharelevel')
if not data.get('delete'):
try:
epsharelevel = EvaluationPointLevel(int(epsharelevel)).value
except:
raise ParamsError('分享等级目前只支持3级')
doid = data.get('doid')
title = data.get('eptitle') or ''
if len(title) > 4:
raise ParamsError('分享图标题 长度超标')
analysis = data.get('epanalysis') or ''
if len(analysis) > 12:
raise ParamsError('初步分析 长度超标')
evaluation = data.get('epevaluation') or ''
if len(evaluation) > 162:
raise ParamsError('评估建议 长度超标')
award = data.get('epaward') or ''
if len(award) > 15:
raise ParamsError('奖励语 长度超标')
shareWords = data.get('epshareWords') or ''
if len(shareWords) > 63:
raise ParamsError('分享文案 长度超标')
ep_dict = {
"EVid": data.get('evid'),
"EPstart": epstart,
"EPtitle": title,
"EPanalysis": analysis,
"EPevaluation": evaluation,
"EPshareWords": shareWords,
"EPshareLevel": epsharelevel,
"EPend": epend,
"EPanswer": data.get('epanswer')
}
if epsharelevel == EvaluationPointLevel.good.value:
if not award:
raise ParamsError('请输入奖励词')
ep_dict['EPaward'] = award
ep_dict['DOid'] = ''
ep_dict['DOname'] = ''
elif epsharelevel == EvaluationPointLevel.vigilant.value:
doctor = Doctor.query.filter(Doctor.DOid == doid,
Doctor.isdelete == 0).first()
if not doctor:
raise ParamsError('当前医生不存在')
ep_dict['DOid'] = doid
ep_dict['DOname'] = doctor.DOname
ep_dict['EPaward'] = ''
else:
ep_dict['EPaward'] = ''
ep_dict['DOid'] = ''
ep_dict['DOname'] = ''
epid = data.get("epid")
if data.get('evid'):
filter_args = [
EvaluationPoint.EVid == data.get('evid'),
EvaluationPoint.isdelete == 0
]
if epid:
filter_args.append(EvaluationPoint.EPid != epid)
ep_list = EvaluationPoint.query.filter(*filter_args).all()
for ep in ep_list:
if not (epstart > Decimal(str(ep["EPend"] or 0))
or epend < Decimal(str(ep["EPstart"]) or 0)):
return PointError('存在重叠分数区间')
with db.auto_commit():
if not epid:
# 新增
ep_dict["EPid"] = str(uuid.uuid1())
ep_instance = EvaluationPoint.create(ep_dict)
msg = "新增成功"
else:
ep_instance = EvaluationPoint.query.filter(
EvaluationPoint.EPid == epid).first_("未找到该分数区间")
if data.get("delete"):
ep_instance.update({"isdelete": 1})
msg = "删除成功"
else:
ep_instance.update(ep_dict)
msg = "修改成功"
db.session.add(ep_instance)
return Success(message=msg)
def set_course(self):
"""
课程排班
"""
data = parameter_required(
('clid', 'costarttime', 'coendtime', 'conum'))
coid = data.get('coid')
classes = Classes.query.filter(
Classes.CLid == data.get('clid')).first_("未找到课程信息，请联系管理员")
doctor = Doctor.query.filter(Doctor.DOid == request.user.id,
Doctor.isdelete == 0).first()
# 时间控制
start_time = datetime.datetime.strptime(data.get('costarttime'),
"%Y-%m-%d %H:%M:%S")
end_time = datetime.datetime.strptime(data.get('coendtime'),
"%Y-%m-%d %H:%M:%S")
if not (end_time > start_time > datetime.datetime.now()):
raise ParamsError('课程结束时间要大于开始时间, 开始时间要大于当前时间')
if start_time.date() != end_time.date():
return {
"status": 405,
"status_code": 405301,
"message": "课程开始结束时间需要同一天"
}
co_dict = {
"CLid": data.get("clid"),
"CLname": classes["CLname"],
"DOid": request.user.id,
"DOname": doctor["DOname"],
"COstarttime": data.get("costarttime"),
"COendtime": data.get("coendtime"),
"COnum": data.get("conum"),
"COstatus": 101
}
with db.auto_commit():
if not coid:
co_dict["COid"] = str(uuid.uuid1())
co_instance = Course.create(co_dict)
msg = "创建成功"
# 添加开始异步任务
add_async_task(func=change_course_status,
start_time=start_time,
func_args=(co_dict["COid"], ),
conn_id='start_course{}'.format(
co_dict["COid"]))
# 添加结束异步任务
add_async_task(func=change_course_status,
start_time=end_time,
func_args=(co_dict["COid"], True),
conn_id='end_course{}'.format(co_dict["COid"]))
else:
# 判断课程排班状态和已报名人数，已开始/已结束或者存在报名人员不可修改
course = Course.query.filter(Course.COid == coid).first()
if course["COstatus"] != 101:
return AuthorityError("无权限")
subscribe = Subscribe.query.filter(
Subscribe.COid == coid).all()
if subscribe:
return AuthorityError("已有人报名，不可修改")
co_instance = Course.query.filter(
Course.COid == coid).first_('未找到该课程排班信息')
co_instance.update(co_dict, null='not')
msg = '编辑成功'
cancel_async_task(conn_id='start_course{}'.format(
co_instance.COid)) # 取消已有的开始时间异步任务
cancel_async_task(conn_id='end_course{}'.format(
co_instance.COid)) # 取消已有的结束时间异步任务
# 重新添加开始异步任务
add_async_task(func=change_course_status,
start_time=start_time,
func_args=(co_instance.COid, ),
conn_id='start_course{}'.format(
co_instance.COid))
# 重新添加结束异步任务
add_async_task(func=change_course_status,
start_time=end_time,
func_args=(co_instance.COid, True),
conn_id='end_course{}'.format(co_instance.COid))
db.session.add(co_instance)
return Success(message=msg, data={"coid": co_instance.COid})
def add_or_update_video(self):
data = parameter_required()
viid = data.get('viid')
doid = getattr(request, 'user').id
with db.auto_commit():
if viid:
video = Video.query.filter(
Video.VIid == viid, Video.isdelete == 0).first()
current_app.logger.info('get video {} '.format(video))
# 优先判断删除
if data.get('delete'):
if not video:
raise ParamsError('视频已删除')
current_app.logger.info('删除视频 {}'.format(doid))
video.isdelete = 1
db.session.add(video)
return Success('删除成功', data=viid)
# 执行update
if video:
update_dict = video.get_update_dict(data)
if update_dict.get('VIid'):
update_dict.pop('VIid')
if update_dict.get('DOid'):
update_dict.pop('DOid')
if update_dict.get('VIsort', 0):
try:
int(update_dict.get('VIsort'))
except:
raise ParamsError('排序请输入整数')
video.update(update_dict)
current_app.logger.info('更新视频 {}'.format(viid))
db.session.add(video)
return Success('更新成功', data=viid)
# 添加
data = parameter_required({
'viname': '剧集名',
'vimedia': '视频路由',
'vidur': '视频时长',
'vithumbnail': '视频缩略图', })
viid = str(uuid.uuid1())
if data.get('visort', 0):
try:
int(data.get('visort', 0))
except:
raise ParamsError('排序请输入整数')
doctor = Video.create({
'DOid': doid,
'VIid': viid,
'VIname': data.get('viname'),
'VImedia': data.get('vimedia'),
'VIthumbnail': data.get('vithumbnail'),
'SEid': data.get('seid'),
'VIdur': data.get('vidur'),
'VIbriefIntroduction': data.get('vibriefintroduction'),
'VIsort': data.get('visort', 0),
})
current_app.logger.info('创建视频 {}'.format(data.get('viname')))
db.session.add(doctor)
return Success('创建视频成功', data=viid)
def _judge_point(self, pttype, uitype, usid, uiintegral=None):
"""判断积分是否可以写入, 如果可以，则写入，如果不可以，则pass"""
# 前台多api调用，传入type，基于pttime和len(userintegral)判断是否写入
with db.auto_commit():
if uitype == 1:
"""收入"""
pointtask = PointTask.query.filter(PointTask.PTtype == pttype).first_("该类型错误")
pttime = int(pointtask.PTtime or 0)
ui_dict = {
"UIid": str(uuid.uuid1()),
"USid": usid,
"UIintegral": pointtask.PTnumber,
"UIaction": pttype,
"UItype": uitype,
"UItrue": 0
}
if pttime > 0:
# 每日限制次数
time_start = datetime.datetime(datetime.datetime.now().year, datetime.datetime.now().month,
datetime.datetime.now().day, 0, 0, 0)
time_end = datetime.datetime(datetime.datetime.now().year, datetime.datetime.now().month,
datetime.datetime.now().day, 23, 59, 59)
# 当日已完成次数
userintegral = UserIntegral.query.filter(UserIntegral.createtime > time_start,
UserIntegral.createtime < time_end,
UserIntegral.USid == usid,
UserIntegral.isdelete == 0,
UserIntegral.UIaction == pttype).all()
current_app.logger.info('get userintegral = {} get pttime = {}'.format(len(userintegral), pttime))
if len(userintegral) >= pttime:
return 0
else:
ui_instance = UserIntegral.create(ui_dict)
elif pttime < 0:
# 一次性
userintegral = UserIntegral.query.filter(UserIntegral.isdelete == 0,
UserIntegral.UIaction == pttype).all()
if userintegral:
return 0
else:
ui_instance = UserIntegral.create(ui_dict)
else:
# 不限次
ui_instance = UserIntegral.create(ui_dict)
elif uitype == 2:
"""支出"""
ui_dict = {
"UIid": str(uuid.uuid1()),
"USid": usid,
"UIintegral": uiintegral,
"UIaction": pttype,
"UItype": uitype,
"UItrue": 0
}
ui_instance = UserIntegral.create(ui_dict)
else:
return SystemError("服务端异常")
db.session.add(ui_instance)
return 1
def add_or_update_example(self):
data = parameter_required()
exid = data.get('exid')
with db.auto_commit():
if exid:
exm = Example.query.filter(Example.EXid == exid,
Example.isdelete == 0).first()
# 优先判断删除
if data.get('delete'):
if not exm:
raise ParamsError('案例已删除')
current_app.logger.info('删除科室 {}'.format(exid))
exm.isdelete = 1
db.session.add(exm)
return Success('删除成功', data=exid)
# 执行update
if exm:
update_dict = exm.get_update_dict(data)
if update_dict.get('EXid'):
update_dict.pop('EXid')
if update_dict.get('EXtreated'):
extreated = update_dict.get('EXtreated')
if not isinstance(extreated, datetime):
self._trans_time(str(extreated))
if update_dict.get('EXsort'):
try:
int(update_dict.get('EXsort'))
except:
raise ParamsError('排序请输入整数')
if update_dict.get('EXgender'):
try:
update_dict['EXgender'] = Gender(
int(update_dict.get('EXgender'))).value
except:
raise ParamsError('性别数据有误')
exm.update(update_dict)
current_app.logger.info('更新科室 {}'.format(exid))
db.session.add(exm)
return Success('更新成功', data=exid)
# 添加
data = parameter_required({
'exname': '患者姓名',
'exgender': '性别',
'syid': '症状',
'exalpha': '主图'
})
exid = str(uuid.uuid1())
if data.get('exsort', 0):
try:
int(data.get('exsort', 0))
except:
raise ParamsError('排序请输入整数')
exm = Example.create({
'EXid':
exid,
"SYid":
data.get('syid'),
'EXname':
data.get('exname'),
'EXgender':
data.get('exgender'),
'EXage':
data.get('exage'),
'EXheight':
data.get('exheight'),
'EXweight':
data.get('exweight'),
'EXaddr':
data.get('exaddr'),
'EXtreated':
data.get('extreated'),
'EXchiefComplaint':
data.get('exchiefcomplaint'),
'EXclinicVisitHistory':
data.get('exclinicvisithistory'),
'EXcaseAnalysis':
data.get('excaseanalysis'),
'EXinspectionResults':
data.get('exinspectionresults'),
'EXdiagnosis':
data.get('exdiagnosis'),
'EXtreatmentPrinciple':
data.get('extreatmentprinciple'),
'EXtreatmentOutcome':
data.get('extreatmentoutcome'),
'EXperoration':
data.get('experoration'),
'EXbriefIntroduction':
data.get('exbriefintroduction'),
'EXalpha':
data.get('exalpha'),
'EXsort':
data.get('exsort'),
})
current_app.logger.info('创建案例 {}'.format(data.get('exname')))
db.session.add(exm)
return Success('创建科室成功', data=exid)
def create(self):
data = parameter_required()
usid = getattr(request, 'user').id
ucid = data.get('ucid')
prid = data.get('prid')
omnum = data.get('omnum', 1)
uaid = data.get('uaid')
smid = data.get('smid')
clid = data.get('clid')
omtype = data.get('omtype')
wallet_payment = True if str(
data.get('wallet_payment')) == '1' else False
omid = str(uuid.uuid1())
with db.auto_commit():
now = datetime.now()
user = User.query.filter(User.USid == usid,
User.isdelete == 0).first_('token过期, 请刷新')
if omtype == OrderMainType.product.value:
ua = UserAddress.query.filter(
UserAddress.UAid == uaid, UserAddress.USid == usid,
UserAddress.isdelete == 0).first_('地址已删除')
apname, acname, aaname = db.session.query(
AddressProvince.APname, AddressCity.ACname,
AddressArea.AAname).filter(
AddressArea.AAid == ua.AAid,
AddressCity.ACid == AddressArea.ACid,
AddressProvince.APid == AddressCity.APid,
).first()
omrecvaddress = '{}{}{}{}'.format(apname, acname, aaname,
ua.UAtext)
else:
ua = None
omrecvaddress = None
uc = None
if ucid:
# 优惠券是否可用
uc = CouponUser.query.filter(
CouponUser.UCid == ucid, CouponUser.isdelete == 0,
CouponUser.COstarttime <= now, CouponUser.COendtime >= now,
CouponUser.UCalreadyuse ==
CouponUserStatus.not_use.value).first_('优惠券已使用')
# usecoupon = False
try:
omnum = int(omnum)
if omnum <= 0:
raise ParamsError('{} 需要是正整数'.format('商品数量'))
except:
raise ParamsError('{}需要是整数'.format('商品数量'))
opayno = wx_pay.nonce_str
try:
omtype = OrderMainType(int(str(omtype))).value
except:
raise ParamsError('订单创建异常')
if omtype == OrderMainType.product.value:
body, truemount, omintegralpayed = self._create_product_order(
prid, omid, omnum, user, opayno, ua, omrecvaddress, uc)
elif omtype == OrderMainType.setmeal.value:
omintegralpayed = 0
if smid == "1":
omnum = 1
elif smid == "2":
pass
else:
setmeal = Setmeal.query.filter(
Setmeal.SMid == smid, Setmeal.isdelete == 0).first()
omnum = setmeal.SMnum
body, truemount = self._create_setmeal_order(
smid, clid, omid, user, uc, omnum, opayno, wallet_payment)
else:
raise ParamsError('订单创建异常')
from ..extensions.tasks import auto_cancle_order
# auto_cancle_order.apply_async(args=(omid,), countdown=30 * 60, expires=40 * 60, )
# todo 修改自动取消为30 minute
add_async_task(func=auto_cancle_order,
start_time=now + timedelta(minutes=30),
func_args=(omid, ))
# # 生成支付信息
# body = product.PRtitle
openid = user.USopenid
# todo 修改支付参数获取
if not truemount:
pay_type = OrderPayType.integral.value
pay_args = 'integralpay'
self._over_ordermain(omid)
elif not omintegralpayed:
if wallet_payment and omtype == OrderMainType.setmeal.value:
if truemount > user.USbalance:
raise StatusError('用户余额不足: {}'.format(user.USbalance))
self._wallet_trade_setmeal(user, truemount, omid)
pay_args = 'wallet_payment'
pay_type = OrderPayType.wallet.value
else:
pay_args = self._pay_detail(opayno,
float(truemount),
body,
openid=openid)
# pay_args = 'wxpay'
pay_type = OrderPayType.wx.value
else:
pay_args = self._pay_detail(opayno,
float(truemount),
body,
openid=openid)
# pay_args = 'wxpay'
pay_type = OrderPayType.mix.value
response = {'paytype': pay_type, 'args': pay_args}
return Success('下单成功', data=response)
def add_or_update_dep(self):
data = parameter_required()
deid = data.get('deid', '')
with db.auto_commit():
if deid:
dep = Departments.query.filter(
Departments.DEid == deid,
Departments.isdelete == 0).first()
# 优先判断删除
if data.get('delete'):
if not dep:
raise ParamsError('科室已删除')
current_app.logger.info('删除科室 {}'.format(deid))
dep.isdelete = 1
db.session.add(dep)
return Success('删除成功', data=deid)
# 执行update
if dep:
update_dict = dep.get_update_dict(data)
if update_dict.get('DEid'):
update_dict.pop('DEid')
if update_dict.get('DEsort'):
try:
int(update_dict.get('DEsort'))
except:
raise ParamsError('排序请输入整数')
# 更新症状
if data.get('symptoms'):
self._add_or_update_symptom(dep, data.get('symptoms'))
update_dict['DEalpha'] = data.get('dalpha')
dep.update(update_dict)
current_app.logger.info('更新科室 {}'.format(deid))
db.session.add(dep)
return Success('更新成功', data=deid)
# 添加
data = parameter_required({
'dename': '科室名',
'dalpha': '科室主图',
'deintroduction': '科室介绍',
'deicon': '科室小icon',
'deicon2': '科室大icon'
})
deid = str(uuid.uuid1())
if data.get('desort', 0):
try:
int(data.get('desort', 0))
except:
raise ParamsError('排序请输入整数')
dep = Departments.create({
'DEid':
deid,
'DEname':
data.get('dename'),
'DEalpha':
data.get('dalpha'),
'DEintroduction':
data.get('deintroduction'),
'DEicon':
data.get('deicon'),
'DEsort':
data.get('desort', 0),
'DEicon2':
data.get('deicon2')
})
if data.get('symptoms'):
self._add_or_update_symptom(dep, data.get('symptoms'))
current_app.logger.info('创建科室 {}'.format(data.get('dename')))
db.session.add(dep)
return Success('创建科室成功', data=deid)
def set_coupon(self):
"""
创建/编辑/删除优惠券
"""
if not is_admin():
return AuthorityError('无权限')
data = parameter_required(('costarttime', "coendtime", "cosubtration", "colimitnum")
if not request.json.get('delete') else('coid',))
if data.get('codownline'):
codownline = data.get('codownline')
else:
codownline = 0
costarttime = data.get('costarttime')
coendtime = data.get('coendtime')
if costarttime:
start_time = datetime.datetime.strptime(costarttime, "%Y-%m-%d %H:%M:%S")
else:
start_time = datetime.datetime.now()
if coendtime:
end_time = datetime.datetime.strptime(coendtime, "%Y-%m-%d %H:%M:%S")
else:
end_time = datetime.datetime.now()
co_dict = {
'COstarttime': costarttime,
'COendtime': coendtime,
'COdownline': codownline,
'COlimitnum': data.get('colimitnum'),
'COsubtration': Decimal(str(data.get('cosubtration') or 0)),
'COgetnum': 0
}
coid = data.get('coid')
with db.auto_commit():
if not coid:
"""新增"""
if end_time < start_time or datetime.datetime.now() > start_time:
return TimeError()
co_dict['COid'] = str(uuid.uuid1())
co_dict["COstatus"] = 501
co_instance = Coupon.create(co_dict)
msg = '添加成功'
# 添加优惠券到期时的定时任务
add_async_task(func=change_coupon_status, start_time=end_time,
func_args=(co_dict['COid'],), conn_id='end_coupon{}'.format(co_dict['COid']))
else:
"""修改/删除"""
co_instance = Coupon.query.filter(Coupon.COid == coid).first_('未找到该优惠券信息')
cancel_async_task(conn_id='end_coupon{}'.format(co_instance.COid)) # 取消已有定时任务
if data.get('delete'):
co_instance.update({'isdelete': 1})
msg = '删除成功'
else:
if not (end_time > start_time >= datetime.datetime.now()):
raise TimeError('结束时间需大于开始时间，开始时间需大于当前时间')
co_instance.update(co_dict, null='not')
msg = '编辑成功'
# 重新添加优惠券到期时的定时任务
add_async_task(func=change_coupon_status, start_time=end_time,
func_args=(co_instance.COid,), conn_id='end_coupon{}'.format(co_instance.COid))
db.session.add(co_instance)
return Success(message=msg)
def add_or_update_product(self):
data = parameter_required()
# return
# todo 修复
adid = getattr(request, 'user').id
admin = Admin.query.filter(
Admin.ADid == adid, Admin.isdelete == 0,
Admin.ADstatus == AdminStatus.normal.value).first_('当前管理员账号已冻结')
prid, prprice, prvipprice, prtype, prstatus, printegral, prvipintegral, prstock, prsort, prdetails, smnum = (
data.get('prid'), data.get('prprice'), data.get('prvipprice'),
data.get('prtype'), data.get('prstatus'), data.get('printegral'),
data.get('prvipintegral'), data.get('prstock'), data.get('prsort'),
data.get('prdetails'), data.get('smnum'))
deid = data.get('deid')
if prprice:
prprice = self._trans_decimal(prprice)
if prvipprice:
prvipprice = self._trans_decimal(prvipprice)
if prtype:
try:
prtype = ProductType(int(prtype)).value
except:
raise ParamsError('商品类型参数异常')
if prtype == ProductType.coupon.value and not data.get('coid'):
raise ParamsError('缺少优惠券参数')
if prtype == ProductType.package.value and not data.get('clid'):
raise ParamsError('缺少课程参数')
if prstatus:
try:
prstatus = ProductStatus(int(str(prstatus))).value
except:
raise ParamsError('商品状态参数异常')
if data.get('coid') and prtype == ProductType.coupon.value:
# 优惠券是否可用
Coupon.query.filter(Coupon.COid == data.get('coid'),
Coupon.COstatus == CouponStatus.use.value,
Coupon.isdelete == 0).first_('优惠券不可用')
if data.get('clid') and prtype == ProductType.package.value:
# 课程是否可用
Classes.query.filter(Classes.CLid == data.get('clid'),
Classes.isdelete == 0).first_('课程不存在')
if printegral:
printegral = self._check_int(printegral, '商品积分')
if prvipintegral:
prvipintegral = self._check_int(prvipintegral, '商品积分')
if prstock:
prstock = self._check_int(prstock, '商品库存')
if prsort:
prsort = self._check_int(prsort, '商品排序')
if smnum:
smnum = self._check_int(smnum, '课时数')
if prdetails:
if not isinstance(prdetails, list):
raise ParamsError('prdetails 格式不对')
if deid:
Departments.query.filter(Departments.DEid == deid,
Departments.isdelete == 0).first_('科室已删除')
else:
deid = ''
with db.auto_commit():
if prid:
product = Products.query.filter(
Products.PRid == prid, Products.isdelete == 0).first()
current_app.logger.info('get product {} '.format(product))
# 优先判断删除
if data.get('delete'):
if not product:
raise ParamsError('商品已删除')
current_app.logger.info('删除商品 {}'.format(prid))
product.isdelete = 1
db.session.add(product)
return Success('删除成功', data=prid)
if product.PRstatus == ProductStatus.usual.value and prstatus == ProductStatus.usual.value:
raise StatusError('商品需要先下架才能修改')
# 执行update
if product:
update_dict = product.get_update_dict(data)
if prprice:
update_dict['PRprice'] = prprice
if prvipprice:
update_dict['PRvipPrice'] = prvipprice
if prtype:
update_dict['PRtype'] = prtype
if prstatus:
update_dict['PRstatus'] = prstatus
if printegral:
update_dict['PRintegral'] = printegral
if prvipintegral:
update_dict['PRvipIntegral'] = prvipintegral
if prstock:
update_dict['PRstock'] = prstock
if prsort:
update_dict['PRsort'] = prsort
if smnum:
update_dict['SMnum'] = smnum
update_dict['DEid'] = deid
product.update(update_dict)
current_app.logger.info('更新商品信息 {}'.format(prid))
db.session.add(product)
return Success('更新成功', data=prid)
# 添加
data = parameter_required({
'prtitle': '商品名',
'prtype': '商品类型',
'prstock': '库存'
})
prid = str(uuid.uuid1())
product = Products.create({
'PRid': prid,
'PRtitle': data.get('prtitle'),
'PRtype': prtype,
'PRmedia': data.get('prmedia'),
'PRstatus': ProductStatus.auditing.value,
'PRprice': prprice,
'PRvipPrice': prvipprice,
'PRintegral': printegral,
'PRvipIntegral': prvipintegral,
'PRstock': prstock,
'COid': data.get('coid'),
'CLid': data.get('clid'),
'PRdetails': data.get('prdetails'),
'PRdesc': data.get('prdesc'),
'PRsort': prsort,
'DEid': deid,
'SMnum': smnum,
})
current_app.logger.info('{} 创建商品 {}'.format(
admin.ADid, data.get('prtitle')))
db.session.add(product)
return Success('创建商品成功', data=prid)
def set_activity(self):
"""管理员 添加/编辑活动"""
data = request.json
acstarttime, acnumber = data.get('acstarttime'), data.get('acnumber')
acid = data.get('acid')
time_now = datetime.now()
if acstarttime and not validate_datetime(acstarttime):
raise ParamsError('活动时间格式错误')
acstarttime = datetime.strptime(
acstarttime, format_for_web_second) if acstarttime else None
if acstarttime and acstarttime <= time_now:
raise ParamsError('活动时间应大于当前时间')
if acnumber and (not str(acnumber).isdigit() or int(acnumber) == 0):
raise ParamsError('活动人数应为大于0的整数')
required_dict = {
'acname': '活动名称',
'acbanner': '活动图片',
'acorganizer': '举办人',
'acstarttime': '活动时间',
'aclocation': '活动地点',
'acdetail': '活动介绍',
'acnumber': '活动人数'
}
ac_dict = {
'ACname': data.get('acname'),
'ACbanner': data.get('acbanner'),
'ACorganizer': data.get('acorganizer'),
'ACstartTime': acstarttime,
'AClocation': data.get('aclocation'),
'ACdetail': data.get('acdetail'),
'ACnumber': acnumber
}
with db.auto_commit():
if not acid:
if Activity.query.filter(
Activity.isdelete == false(),
Activity.ACname == data.get('acname'),
Activity.ACstartTime == acstarttime).first():
raise ParamsError('您已添加过 {} 活动'.format(data.get('acname')))
parameter_required(required_dict, datafrom=data)
ac_dict['ACid'] = str(uuid.uuid1())
ac_dict['ADid'] = getattr(request, 'user').id
ac_dict['ACstatus'] = ActivityStatus.ready.value
activity = Activity.create(ac_dict)
msg = '添加成功'
# 添加异步任务
add_async_task(func=change_activity_status,
start_time=acstarttime,
func_args=(ac_dict['ACid'], ),
conn_id='start_activity{}'.format(
ac_dict['ACid']))
else:
activity = Activity.query.filter(
Activity.isdelete == false(),
Activity.ACid == acid).first_('活动不存在')
self._can_activity_edit(activity)
# 取消已有的异步任务
cancel_async_task(
conn_id='start_activity{}'.format(activity.ACid))
if data.get('delete'):
activity.update({'isdelete': True})
msg = '删除成功'
elif data.get('close'):
activity.update({'ACstatus': ActivityStatus.close.value})
msg = '活动关闭成功'
else:
parameter_required(required_dict, datafrom=data)
# 重新添加异步任务
add_async_task(func=change_activity_status,
start_time=acstarttime,
func_args=(activity.ACid, ),
conn_id='start_activity{}'.format(
activity.ACid))
ac_dict['ACstatus'] = ActivityStatus.ready.value
activity.update(ac_dict)
msg = '更新成功'
db.session.add(activity)
return Success(message=msg, data={'acid': activity.ACid})
def set_review(self):
"""
创建评论
"""
if not is_user():
return AuthorityError()
data = parameter_required(("rvcontent", "rvtype", "rvtypeid", "rvnum"))
usid = request.user.id
rvtype = int(data.get('rvtype'))
rvtypeid = data.get('rvtypeid')
if rvtype == 401:
"""课程"""
subscribe = Subscribe.query.filter(Subscribe.SUid == rvtypeid).first_("未找到预约信息")
classes = Course.query.filter(Course.COid == subscribe.COid).first_("未找到该课程排班")
doid = classes["DOid"]
elif rvtype == 402:
"""挂诊"""
register = Register.query.filter(Register.REid == rvtypeid).first_("未找到该挂诊信息")
doid = register["DOid"]
elif rvtype == 403:
"""活动"""
doid = None
elif rvtype == 404:
"""案例"""
doid = None
elif rvtype == 405:
"""视频"""
video = Video.query.filter(Video.VIid == rvtypeid).first_("未找到该视频信息")
doid = video["DOid"]
else:
return StatusError("评论种类异常")
rvid = str(uuid.uuid1())
user_dict = User.query.filter(User.USid == usid).first_("未找到该用户")
if (rvtype == 401 or rvtype == 402) and Review.query.filter(
Review.isdelete == 0, Review.USid == usid, Review.RVtype == rvtype,
Review.RVtypeid == data.get('rvtypeid')).first():
raise StatusError('您已进行过评价')
rv_dict = {
"USid": usid,
"USname": user_dict["USname"],
"USavatar": user_dict["USavatar"],
"RVcontent": data.get('rvcontent'),
"DOid": doid,
"RVtype": rvtype,
"RVtypeid": data.get('rvtypeid'),
"RVnum": Decimal(str(data.get('rvnum') or 0))
}
if data.get('rppicture_list'):
rppicture_list = data.get('rppicture_list')
else:
rppicture_list = []
with db.auto_commit():
if rvtype == 401:
subscribe_instance = Subscribe.query.filter(Subscribe.SUid == rvtypeid).first_("未找到预约信息")
subscribe_instance.update({
"SUstatus": 203
})
db.session.add(subscribe_instance)
elif rvtype == 402:
register_instance = Register.query.filter(Register.REid == rvtypeid).first_("未找到该挂诊信息")
register_instance.update({
"REstatus": 4
})
db.session.add(register_instance)
elif rvtype == 403:
# 更改用户活动状态为已评价
rv_dict["RVtypeid"] = self._change_user_activity_comment_status(rvtypeid, usid)
else:
pass
for repicture in rppicture_list:
rp_dict = {
"RPid": str(uuid.uuid1()),
"RVid": rvid,
"RPpicture": repicture["rppicture"]
}
rv_instance = ReviewPicture.create(rp_dict)
db.session.add(rv_instance)
rv_dict["RVid"] = rvid
rv_instance = Review.create(rv_dict)
db.session.add(rv_instance)
from .CConfig import CConfig
from ..config.enums import PointTaskType
CConfig()._judge_point(PointTaskType.review.value, 1, usid)
return Success("评论成功")
def make_evaluation(self):
"""提交评测"""
data = parameter_required(('evid', 'ei_list'))
# user = getattr(request, 'user')
if not is_user():
raise AuthorityError('权限不足')
usid = getattr(request, 'user').id
evid = data.get('evid')
anid = str(uuid.uuid1())
with db.auto_commit():
point = Decimal(0.0)
evaluationitem_all = EvaluationItem.query.filter(
EvaluationItem.isdelete == 0,
EvaluationItem.EVid == evid).all()
if len(evaluationitem_all) != len(data.get('ei_list')):
return EvaluationNumError()
for ei in data.get('ei_list'):
eiid = ei["eiid"]
eaid = ei["eaid"]
evaluationitem = EvaluationItem.query.filter(EvaluationItem.EIid == eiid,
EvaluationItem.isdelete == 0) \
.first_("未找到该题目")
evaluationanswer = EvaluationAnswer.query.filter(EvaluationAnswer.EAid == eaid,
EvaluationAnswer.isdelete == 0) \
.first_("未找到该选项")
ai_dict = {
"AIid": str(uuid.uuid1()),
"EIname": evaluationitem["EIname"],
"EAindex": evaluationanswer["EAindex"],
"EApoint": evaluationanswer["EApoint"],
"EAname": evaluationanswer["EAname"],
"USid": usid,
"ANid": anid
}
point = Decimal(str(evaluationanswer["EApoint"]
or 0)) + Decimal(str(point or 0))
ai_instance = AnswerItem.create(ai_dict)
db.session.add(ai_instance)
evaluation = Evaluation.query.filter(
Evaluation.isdelete == 0,
Evaluation.EVid == evid).first_("未找到该评测")
# 总积分逻辑改为平均分
# point = Decimal(str(point / len(evaluationitem_all)))
current_app.logger.info(point)
evaluationpoint = EvaluationPoint.query.filter(EvaluationPoint.EPstart <= point,
EvaluationPoint.EVid == evid,
EvaluationPoint.EPend >= point,
EvaluationPoint.isdelete == 0) \
.first_("未找到评测结论")
answer = evaluationpoint["EPanswer"]
an_dict = {
"ANid": anid,
"USid": usid,
"EVid": evid,
"EVname": evaluation["EVname"],
"EVpoint": point,
"EPanswer": answer
}
an_instance = Answer.create(an_dict)
share_url = Share(usid, point, an_instance).drawshare()
an_instance.EVshare = share_url
db.session.add(an_instance)
# todo 创建分享图
from .CConfig import CConfig
from ..config.enums import PointTaskType
CConfig()._judge_point(PointTaskType.make_evaluation.value, 1, usid)
return Success(message="提交评测成功",
data={
"answer": answer,
'share': HTTP_HOST + share_url
})
def add_or_update_doctor(self):
data = parameter_required()
doid = data.get('doid')
# password = data.get('dopassword')
dotel = data.get('dotel')
if dotel:
validate_telephone(dotel)
with db.auto_commit():
if doid:
doctor = Doctor.query.filter(Doctor.DOid == doid,
Doctor.isdelete == 0).first()
current_app.logger.info('get doctor {} '.format(doctor))
# 优先判断删除
if data.get('delete'):
if not doctor:
raise ParamsError('医生已删除')
current_app.logger.info('删除科室 {}'.format(doid))
doctor.isdelete = 1
db.session.add(doctor)
return Success('删除成功', data=doid)
# 执行update
if doctor:
if Doctor.query.filter(Doctor.DOid != doid,
Doctor.DOtel == dotel,
Doctor.isdelete == 0).first():
raise ParamsError(f'已存在使用手机号"{dotel}"的其他医生账户, 请检查后重试')
update_dict = doctor.get_update_dict(data)
if update_dict.get('DOid'):
update_dict.pop('DOid')
if update_dict.get('DOsort', 0):
try:
int(update_dict.get('DOsort'))
except:
raise ParamsError('排序请输入整数')
if update_dict.get('DOpassword'):
update_dict.pop('DOpassword')
# 更新医生列表图片
if data.get('doctorlistpic'):
self._add_or_update_list_pic(doctor,
data.get('doctorlistpic'))
# 更新医生主图
if data.get('doctormainpic'):
self._add_or_update_media_pic(
doctor, data.get('doctormainpic'),
DoctorMetiaType.mainpic.value)
# 更新医生二维码
if data.get('doctorqrpic'):
self._add_or_update_media_pic(
doctor, data.get('doctorqrpic'),
DoctorMetiaType.qrpic.value)
doctor.update(update_dict)
current_app.logger.info('更新医生 {}'.format(doid))
db.session.add(doctor)
return Success('更新成功', data=doid)
# 添加
data = parameter_required({
'doname': '医生名',
'dotel': '医生电话',
'dotitle': '医生职称',
'deid': '科室',
'doctormainpic': '医生主图',
'dodetails': '医生简介',
'dowxid': '医生微信ID',
'doskilledin': '擅长方向'
})
if Doctor.query.filter(Doctor.DOtel == dotel,
Doctor.isdelete == 0).first():
raise ParamsError(f'已存在使用手机号"{dotel}"的医生账户, 请检查后重试')
doid = str(uuid.uuid1())
if data.get('dosort', 0):
try:
int(data.get('dosort', 0))
except:
raise ParamsError('排序请输入整数')
doctor = Doctor.create({
'DOid':
doid,
'DOname':
data.get('doname'),
'DOtel':
dotel,
'DOtitle':
data.get('dotitle'),
'DOdetails':
data.get('dodetails'),
'DOwxid':
data.get('dowxid'),
'DOskilledIn':
data.get('doskilledin'),
'DOsort':
data.get('dosort', 0),
'DOpassword':
generate_password_hash(str(data.get('dotel'))[-6:]),
'DEid':
data.get('deid')
})
if data.get('doctorlistpic'):
self._add_or_update_list_pic(doctor, data.get('doctorlistpic'))
# 更新医生主图
if data.get('doctormainpic'):
self._add_or_update_media_pic(doctor,
data.get('doctormainpic'),
DoctorMetiaType.mainpic.value)
# 更新医生二维码
if data.get('doctorqrpic'):
self._add_or_update_media_pic(doctor, data.get('doctorqrpic'),
DoctorMetiaType.qrpic.value)
current_app.logger.info('创建医生 {}'.format(data.get('doname')))
db.session.add(doctor)
return Success('创建医生成功', data=doid)
def add_or_update_consultation(self):
data = parameter_required()
doid = getattr(request, 'user').id
conid = data.get('conid')
constarttime, conendtime, conlimit, constatus = data.get('constarttime'), data.get('conendtime'), \
data.get('conlimit'), data.get('constatus')
constarttime = self._check_time(constarttime)
conendtime = self._check_time(conendtime)
now = datetime.now()
if constarttime and constarttime < now:
raise ParamsError('开始时间不能小于当前时间')
if constarttime and conendtime and constarttime > conendtime:
raise ParamsError('结束时间不能小于开始时间')
if conlimit:
try:
conlimit = int(str(conlimit))
if conlimit < 0:
raise ParamsError('限制人数只能为正整数')
except:
raise ParamsError('限制人数只能为正整数')
if constatus:
try:
constatus = ConsultationStatus(int(str(constatus))).value
except:
raise ParamsError('状态修改参数异常')
with db.auto_commit():
if conid:
con = Consultation.query.filter(
Consultation.CONid == conid,
Consultation.isdelete == 0).first()
current_app.logger.info('get doctor {} '.format(con))
# 优先判断删除
if data.get('delete'):
if not con:
raise ParamsError('医生已删除')
current_app.logger.info('删除会诊 {}'.format(conid))
con.isdelete = 1
db.session.add(con)
cancel_async_task(conn_id='change_consultation{}'.format(
conid)) # 取消已有定时任务
return Success('删除成功', data=conid)
# 执行update
if con:
cancel_async_task(conn_id='change_consultation{}'.format(
conid)) # 取消已有定时任务
# 只能修改这个4个字段
update_dict = {}
if constarttime:
update_dict['CONstartTime'] = constarttime
if conendtime:
update_dict['CONendTime'] = conendtime
if constatus:
update_dict['CONstatus'] = constatus
if conlimit:
update_dict['CONlimit'] = conlimit
con.update(update_dict)
current_app.logger.info('更新会诊信息 {}'.format(conid))
db.session.add(con)
# 到开始时间更改状态, 除手动关闭外
if constatus != ConsultationStatus.finish.value:
add_async_task(
func=change_consultation_status,
start_time=constarttime,
func_args=(conid, ),
conn_id='change_consultation{}'.format(conid))
return Success('更新成功', data=conid)
# 添加
data = parameter_required({
'constarttime': '开始时间',
'conlimit': '限制人数'
})
conid = str(uuid.uuid1())
doctor = Doctor.query.filter(Doctor.DOid == doid,
Doctor.isdelete == 0).first_('医生已删除')
dep = Departments.query.filter(
Departments.DEid == doctor.DEid,
Departments.isdelete == 0).first_('科室已删除')
con = Consultation.create({
'CONid': conid,
'DOid': doid,
'CONstartTime': constarttime,
'CONendTime': conendtime,
'CONlimit': conlimit,
'CONnote': data.get('connote'),
'DOname': doctor.DOname,
'DOtel': doctor.DOtel,
'DOtitle': doctor.DOtitle,
'DOdetails': doctor.DOdetails,
'DOwxid': doctor.DOwxid,
'DOskilledIn': doctor.DOskilledIn,
'DEname': dep.DEname,
'DEid': dep.DEid,
})
current_app.logger.info('创建会诊 {}'.format(doid))
db.session.add(con)
# 到开始时间更改状态
add_async_task(func=change_consultation_status,
start_time=constarttime,
func_args=(conid, ),
conn_id='change_consultation{}'.format(conid))
return Success('创建会诊成功', data=conid)
