def approve(self):
"""管理员审批"""
data = request.json
atids = data.get('atids')
if not isinstance(atids, list):
raise ParamsError('atids 格式错误， 应为["id1","id2"]')
if not all(atids):
raise ParamsError('null type in atids')
action = data.get('action')
try:
action = int(action)
ApproveAction(action)
except ValueError:
raise ParamsError('参数错误：action')
atstatus = ApplyStatus.passed.value if ApproveAction.agree.value == action else ApplyStatus.reject.value
instance_list = []
with db.auto_commit():
for atid in atids:
assistance = self._exist_assistance([Assistance.ATid == atid, ])
if not assistance:
current_app.logger.error('atid: {} not found'.format(atid))
continue
assistance.update({'ATstatus': atstatus,
'Reviewer': getattr(request, 'user').id, })
instance_list.append(assistance)
db.session.add_all(instance_list)
return Success('成功')
def _check_int(self, num, paramsname):
if num is None:
return
try:
trans_num = int(num)
if trans_num < 0:
raise ParamsError('{} 需要是正整数'.format(paramsname))
return int(num)
except:
raise ParamsError('{}需要是整数'.format(paramsname))
def list(self):
data = parameter_required()
restatus = int(data.get('restatus', 0))
filter_args = [Register.isdelete == 0, ]
if is_user():
usid = getattr(request, 'user').id
filter_args.append(Register.USid == usid)
telphone = data.get('telphone')
if restatus:
filter_args.append(or_(Register.REstatus > RegisterStatus.transfer.value,
Register.REstatus == RegisterStatus.cancle.value))
elif telphone and telphone != 'null' and not restatus: # 手机号查看报告单时,显示该用户所有挂号记录报告单
filter_args.append(Register.REstatus > RegisterStatus.cancle.value)
else:
filter_args.append(and_(Register.REstatus < RegisterStatus.commenting.value,
Register.REstatus > RegisterStatus.cancle.value))
if telphone:
family = Family.query.filter(Family.FAtel == telphone, Family.USid == usid,
Family.isdelete == 0).first()
if family:
filter_args.append(Register.FAid == family.FAid)
elif is_doctor():
doctor = Doctor.query.filter(Doctor.DOid == getattr(
request, 'user').id, Doctor.isdelete == 0).first_('账号已注销')
filter_args.append(Register.DEid == doctor.DEid)
# index = data.get('index')
if not is_user():
# 后台筛选专用字段
if restatus:
try:
restatus = RegisterStatus(int(str(restatus))).value
except:
raise ParamsError('挂号状态筛选有误')
filter_args.append(Register.REstatus == restatus)
deid, usid, doid, redate, reamorpm = data.get('deid'), data.get('usid'), data.get(
'doid'), data.get('redate'), data.get('reamorpm')
if deid: filter_args.append(Register.DEid == deid)
if usid: filter_args.append(Register.USid == usid)
if doid: filter_args.append(Register.DOid == doid)
redate = self._check_time(redate)
if redate: filter_args.append(or_(Register.REdate == redate, Register.REtansferDate == redate))
if reamorpm is not None:
try:
reamorpm = RegisterAmOrPm(int(str(reamorpm))).value
except:
raise ParamsError('时间段筛选有误')
filter_args.append(or_(Register.REamOrPm == reamorpm, Register.REtansferAmOrPm == reamorpm))
register_list = Register.query.filter(*filter_args).order_by(Register.createtime.desc()).all_with_page()
for register in register_list:
self._fill_resgister(register)
return Success('获取成功', data=register_list)
def __check_password(self, password):
"""
校检密码
"""
if not password or len(password) < 4:
raise ParamsError('密码长度低于4位')
zh_pattern = re.compile(r'[\u4e00-\u9fa5]+')
match = zh_pattern.search(password)
if match:
raise ParamsError(u'密码包含中文字符')
return True
def add_or_update_series(self):
data = parameter_required()
seid = data.get('seid')
doid = getattr(request, 'user').id
with db.auto_commit():
if seid:
series = Series.query.filter(
Series.SEid == seid, Series.isdelete == 0).first()
current_app.logger.info('get series {} '.format(series))
# 优先判断删除
if data.get('delete'):
if not series:
raise ParamsError('剧集已删除')
current_app.logger.info('删除科室 {}'.format(doid))
series.isdelete = 1
db.session.add(series)
return Success('删除成功', data=seid)
# 执行update
if series:
update_dict = series.get_update_dict(data)
if update_dict.get('SEid'):
update_dict.pop('SEid')
if update_dict.get('DOid'):
update_dict.pop('DOid')
if update_dict.get('SEsort', 0):
try:
int(update_dict.get('SEsort'))
except:
raise ParamsError('排序请输入整数')
series.update(update_dict)
current_app.logger.info('更新系列 {}'.format(seid))
db.session.add(series)
return Success('更新成功', data=seid)
# 添加
data = parameter_required({'sename': '剧集名', })
seid = str(uuid.uuid1())
if data.get('sesort', 0):
try:
int(data.get('sesort', 0))
except:
raise ParamsError('排序请输入整数')
doctor = Series.create({
'DOid': doid,
'SEid': seid,
'SEname': data.get('sename'),
'SEsort': data.get('sesort', 0),
})
current_app.logger.info('创建剧集 {}'.format(data.get('sename')))
db.session.add(doctor)
return Success('创建剧集成功', data=doid)
def apply(self):
"""申请"""
data = parameter_required({'atname': '姓名', 'atbirthday': '出生年月', 'atgender': '性别',
'athousehold': '户籍地址', 'ataddress': '家庭地址', 'attelphone': '手机号码',
'idf_code': '验证码', 'arids': '申请人亲属', 'atcondition': '身体状况',
'attreatment': '治疗情况', 'atdetail': '申请援助项目',
'diagnosis': '诊断证明图片', 'poverty': '特困证明图片', 'atdate': '到院日期'})
atname, atgender, atbirthday, attelphone, arids, atdate, diagnosis, poverty = map(lambda x: data.get(x), (
'atname', 'atgender', 'atbirthday', 'attelphone', 'arids', 'atdate', 'diagnosis', 'poverty'))
if not validate_chinese(atname):
raise ParamsError('姓名中包含非汉语字符, 请检查姓名是否填写错误')
validate_arg(r'^[1-2]$', atgender, '参数错误: atgender')
validate_arg(r'^1[1-9][0-9]{9}$', attelphone, '请输入正确的手机号码')
[self._exist_assistance_relative([AssistanceRelatives.ARid == arid], 'arid不存在') for arid in arids]
if not validate_datetime(atbirthday):
raise ParamsError('参数错误: atbirthday')
if not validate_datetime(atdate):
raise ParamsError('参数错误: ardate')
CUser().validate_identifying_code(attelphone, data.get('idf_code'))
assistance_dict = {'ATid': str(uuid.uuid1()), 'USid': getattr(request, 'user').id,
'ATname': atname, 'ATbirthday': atbirthday, 'ATgender': atgender,
'AThousehold': data.get('athousehold'), 'ATaddress': data.get('ataddress'),
'ATtelphone': attelphone, 'ARids': json.dumps(arids),
'ATcondition': data.get('atcondition'), 'ATtreatment': data.get('attreatment'),
'AThospital': data.get('athospital'), 'ATdetail': data.get('atdetail'),
'ATdate': atdate, 'ATincomeProof': data.get('atincomeproof'),
'ATstatus': ApplyStatus.waiting.value
}
if self._exist_assistance([Assistance.USid == assistance_dict['USid'],
Assistance.ATstatus == ApplyStatus.waiting.value]):
raise DumpliError('您已有申请在审核中，等待审核结果后，可再次提交')
instance_list = []
with db.auto_commit():
assistance = Assistance.create(assistance_dict)
instance_list.append(assistance)
[instance_list.append(AssistancePicture.create({'APid': str(uuid.uuid1()),
'ATid': assistance_dict['ATid'],
'APtype': AssistancePictureType.diagnosis.value,
'APimg': img_url})) for img_url in diagnosis]
[instance_list.append(AssistancePicture.create({'APid': str(uuid.uuid1()),
'ATid': assistance_dict['ATid'],
'APtype': AssistancePictureType.poverty.value,
'APimg': img_url})) for img_url in poverty]
db.session.add_all(instance_list)
# 申请公益援助 积分任务
from .CConfig import CConfig
from ..config.enums import PointTaskType
CConfig()._judge_point(PointTaskType.help_someone.value, 1, getattr(request, 'user').id)
return Success('提交成功', data={'ATid': assistance_dict['ATid']})
def get(self):
data = parameter_required('doid')
doid = data.get('doid')
conid = data.get('conid')
doctor = Doctor.query.filter(Doctor.DOid == doid,
Doctor.isdelete == 0).first()
if not doctor:
raise ParamsError('医生已离开')
doctor.fields = [
'DEid', 'DOname', 'DOid', 'DOtitle', 'DOtel', 'DOdetails',
'DOwxid', 'DOskilledIn', 'createtime', 'DOsort'
]
self._fill_department(doctor)
self._fill_doctor_mainpic(doctor)
self._fill_doctor_listpic(doctor)
self._fill_doctor_qrpic(doctor)
if conid:
# 填充会诊信息
self._fill_consultation(doctor, conid)
# doctor.fill('favorablerate', '100%')
# doctor.fill('treatnum', '0')
self._fill_doctor_review(doctor)
return Success('获取成功', data=doctor)
def __check_adname(self, adname):
"""账户名校验"""
if not adname:
return True
suexist = Admin.query.filter(Admin.isdelete == 0, Admin.ADname == adname).first()
if suexist:
raise ParamsError('用户名已存在')
return True
def set_relatives(self):
"""添加/编辑亲属"""
data = parameter_required({'artype': '身份', 'arname': '姓名', 'arage': '年龄',
'arcompany': '工作单位', 'arsalary': '月收入'})
usid = getattr(request, 'user').id
arid, artype = data.get('arid'), data.get('artype')
validate_arg(r'^[12]$', data.get('artype'), '参数错误: artype')
arname, arage, arsalary = map(lambda x: str(data.get(x)).replace(' ', ''), ('arname', 'arage', 'arsalary'))
if not validate_chinese(arname):
raise ParamsError('姓名中包含非汉语字符, 请检查姓名是否填写错误')
validate_arg(r'^[1-9](\d+)?$', arage, '请正确填写年龄')
validate_arg(r'(^[1-9](\d+)?$)|(^0$)', arsalary, '请正确填写月收入')
ar_dict = {'ARtype': artype,
'ARname': arname,
'ARage': arage,
'ARcompany': data.get('arcompany'),
'ARsalary': arsalary}
with db.auto_commit():
if not arid:
if self._exist_assistance_relative([AssistanceRelatives.USid == usid,
AssistanceRelatives.ARname == arname,
AssistanceRelatives.ARtype == artype], ):
raise DumpliError('您已添加过 {}'.format(arname))
ar_dict['ARid'] = str(uuid.uuid1())
ar_dict['USid'] = usid
ar = AssistanceRelatives.create(ar_dict)
msg = '添加成功'
else:
ar = self._exist_assistance_relative([AssistanceRelatives.ARid == arid,
AssistanceRelatives.USid == usid], '未找到任何信息')
if data.get('delete'):
ar.update({'isdelete': True})
msg = '删除成功'
else:
if str(artype) != str(ar.ARtype) and self._exist_assistance_relative(
[AssistanceRelatives.USid == usid,
AssistanceRelatives.ARtype == artype,
AssistanceRelatives.ARid != ar.ARid], ):
raise ParamsError('您已添加过身份为 {} 的亲属，请到相应身份的亲属内修改'
''.format(FamilyType(artype).zh_value))
ar.update(ar_dict)
msg = '修改成功'
db.session.add(ar)
return Success(data={'arid': ar.ARid}, message=msg)
def list(self):
data = parameter_required()
constatus = data.get('constatus', 0)
doid = data.get('doid')
condate = data.get('condate')
filter_args = [
Consultation.isdelete == 0,
]
if is_doctor():
doid = getattr(request, 'user').id
if doid:
filter_args.append(Consultation.DOid == doid)
if not constatus and is_user():
filter_args.append(
Consultation.CONstatus == ConsultationStatus.ready.value)
elif constatus:
try:
constatus = ConsultationStatus(int(str(constatus))).value
except:
raise ParamsError('状态筛选参数异常')
filter_args.append(Consultation.CONstatus == constatus)
if condate:
if not isinstance(condate, date):
try:
condate = datetime.strptime(str(condate),
format_forweb_no_HMS).date()
except:
raise ParamsError('日期筛选 {} 参数错误'.format(
data.get('condate')))
filter_args.append(
cast(Consultation.CONstartTime, Date) == condate)
con_list = Consultation.query.filter(*filter_args).order_by(
Consultation.createtime.desc()).all_with_page()
for con in con_list:
self._fill_doctor_mainpic(con)
con_count = db.session.query(func.count(Enroll.ENid)).filter(
Enroll.CONid == con.CONid, Enroll.isdelete == 0).scalar()
con.fill('conremainder', (int(con.CONlimit) - int(con_count)))
return Success('获取成功', data=con_list)
def _check_time(self, check_time):
if not check_time:
return
if not isinstance(check_time, date):
try:
check_time = datetime.strptime(str(check_time), format_forweb_no_HMS).date()
except:
return ParamsError('日期格式不对，具体格式为{}'.format(format_forweb_no_HMS))
return check_time
def list(self):
data = parameter_required()
usid = getattr(request, 'user').id
omstatus = data.get('omstatus')
omname = data.get('omname')
omtype = data.get('omtype', 0)
filter_args = [
OrderMain.isdelete == 0,
]
try:
omtype = OrderMainType(int(omtype)).value
except:
raise ParamsError('订单类型有误 {}'.format(omtype))
if is_user():
filter_args.append(
OrderMain.OMstatus >= OrderMainStatus.ready.value)
filter_args.append(OrderMain.OMtype == omtype)
filter_args.append(OrderMain.USid == usid)
elif omstatus is not None:
try:
omstatus = OrderMainStatus(int(str(omstatus))).value
except:
raise ParamsError('订单状态筛选参数异常')
filter_args.append(OrderMain.OMstatus == omstatus)
if omname:
filter_args.append(
or_(OrderMain.CLname.ilike('%{}%'.format(omname)),
OrderMain.PRtitle.ilike('%{}%'.format(omname))))
if is_admin():
filter_args.append(OrderMain.OMtype == 0)
omlist = OrderMain.query.filter(*filter_args).order_by(
OrderMain.createtime.desc()).all_with_page()
if is_user():
uh_list = UserHour.query.filter(UserHour.USid == usid,
UserHour.isdelete == 0).all()
# 可用时长统计
smsum = sum([int(uh.UHnum) for uh in uh_list])
return Success('获取成功', data={'omlist': omlist, 'smsum': smsum})
return Success('获取成功', data={'omlist': omlist})
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 _trans_time(self, time_str):
return_str = None
try:
if re.match(r'^\d{4}(-\d{2}){2} \d{2}(:\d{2}){2}$', time_str):
return_str = datetime.strptime(time_str, '%Y-%m-%d %H:%M:%S')
elif re.match(r'^\d{4}(-\d{2}){2} \d{2}:\d{2}$', time_str):
return_str = datetime.strptime(time_str, '%Y-%m-%d %H:%M')
except ValueError:
return_str = None
if not return_str:
raise ParamsError('请检查时间是否填写正确')
return return_str
def _check_time(self, check_time):
if not check_time:
return
# 日期校验
if not isinstance(check_time, datetime):
try:
check_time = datetime.strptime(str(check_time),
format_for_web_second)
except:
raise ParamsError(
'日期格式不对，具体格式为{}'.format(format_for_web_second))
return check_time
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 list(self):
data = parameter_required()
filter_args = [
Products.isdelete == 0,
]
dename = data.get('dename')
if dename:
filter_args.append(Departments.DEname.ilike('%{}%'.format(dename)))
filter_args.append(Departments.DEid == Products.DEid)
if not is_admin():
filter_args.append(Products.PRstatus == ProductStatus.usual.value)
else:
prtitle, prstatus, prtype = data.get('prtitle'), data.get(
'prstatus'), data.get('prtype')
if prtitle:
filter_args.append(
Products.PRtitle.ilike('%{}%'.format(prtitle)))
if prstatus:
try:
prstatus = ProductStatus(int(str(prstatus))).value
except:
raise ParamsError('商品状态异常')
filter_args.append(Products.PRstatus == prstatus)
if prtype:
try:
prtype = ProductType(int(str(prtype))).value
except:
raise ParamsError('商品类型筛选异常')
filter_args.append(Products.PRtype == prtype)
products = Products.query.filter(*filter_args).order_by(
Products.PRsort.asc(), Products.createtime.desc()).all_with_page()
for product in products:
self._fill_coupon(product)
return Success('获取成功', data=products)
def list_assistance(self):
"""管理员获取申请列表"""
args = parameter_required(('page_num', 'page_size'))
as_query = Assistance.query.filter(Assistance.isdelete == false())
atstatus = args.get('atstatus')
if atstatus:
try:
atstatus = int(atstatus)
ApplyStatus(atstatus)
except ValueError:
raise ParamsError('atstatus 参数错误')
as_query = as_query.filter(Assistance.ATstatus == atstatus)
if args.get('usid'):
as_query = as_query.filter(Assistance.USid == args.get('usid'))
assistance_list = as_query.order_by(Assistance.createtime.desc()).all_with_page()
[self._fill_assistance(assistance) for assistance in assistance_list]
return Success(data=assistance_list)
def admin_login(self):
"""管理员登录"""
data = parameter_required(('adname', 'adpassword', 'adtype'))
if data['adtype'] == 1:
# 管理员/超级管理员登录
ad = Admin.query.filter(Admin.isdelete == 0,
Admin.ADname == data.get("adname")).first()
# 密码验证
if ad and check_password_hash(ad.ADpassword, data.get("adpassword")):
token = usid_to_token(ad.ADid, 'Admin', ad.ADlevel, username=ad.ADname)
ad.fields = ['ADname', 'ADheader', 'ADlevel']
ad.fill('adlevel', AdminLevel(ad.ADlevel).zh_value)
ad.fill('adstatus', AdminStatus(ad.ADstatus).zh_value)
with db.auto_commit():
an_instance = AdminActions.create({
'AAid': str(uuid.uuid1()),
'ADid': ad.ADid,
"AAaction": 4,
"AAmodel": "Admin",
'AAdetail': str(data)
})
db.session.add(an_instance)
return Success('登录成功', data={'token': token, "admin": ad})
elif data['adtype'] == 2:
# 医生登录
dc = Doctor.query.filter(Doctor.isdelete == 0, Doctor.DOtel == data.get('adname')).first()
if dc and check_password_hash(dc.DOpassword, data.get('adpassword')):
token = usid_to_token(dc.DOid, 'Doctor', 3, username=dc.DOname)
with db.auto_commit():
an_instance = AdminActions.create({
'AAid': str(uuid.uuid1()),
'ADid': dc.DOid,
"AAaction": 4,
"AAmodel": "Doctor",
'AAdetail': str(data)
})
db.session.add(an_instance)
return Success('登录成功', data={'token': token, 'admin': dc})
return ParamsError("用户名或密码错误")
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 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 _create_setmeal_order(self, smid, clid, omid, user, uc, omnum, opayno,
wallet_payment):
decimal_omnum = Decimal(omnum)
if smid == '1':
cl = Classes.query.filter(Classes.CLid == clid,
Classes.isdelete == 0).first_('课程已结束')
# trueunit = sm.SMprice
trueunit = (Decimal(cl.CLprice) if cl.CLprice else Decimal(0))
smnum = 1
clname = cl.CLname
elif smid == "2":
cl = Classes.query.filter(Classes.CLid == clid,
Classes.isdelete == 0).first_('课程已结束')
smnum = decimal_omnum
trueunit = (Decimal(cl.CLprice) if cl.CLprice else Decimal(0))
clname = cl.CLname
else:
sm = Setmeal.query.join(
Classes, Classes.CLid == Setmeal.CLid).filter(
Setmeal.SMid == smid, Setmeal.CLid == clid,
Setmeal.isdelete == 0,
Classes.isdelete == 0).first_('课时套餐已下架')
smnum = sm.SMnum
clname = sm.CLname
trueunit = (Decimal(sm.SMprice) if sm.SMprice else Decimal(0))
mount = truemount = trueunit * decimal_omnum
ucid = ''
if uc:
if uc.COdownline and truemount >= Decimal(uc.COdownline):
# 优惠后价格
truemount = truemount - Decimal(uc.COsubtration)
if truemount < Decimal(0):
truemount = Decimal(0)
uc.UCalreadyuse = CouponUserStatus.had_use.value
ucid = uc.UCid
db.session.add(uc)
else:
raise ParamsError('商品价格达不到优惠券最低金额')
omstatus = OrderMainStatus.wait_pay.value
if truemount == 0:
omstatus = OrderMainStatus.ready.value
else:
op_instance = OrderPay.create({
'OPayid':
str(uuid.uuid1()),
'OPayno':
opayno,
'OPayType':
OrderPayType.wx.value
if not wallet_payment else OrderPayType.wallet.value,
'OPayMount':
truemount,
})
db.session.add(op_instance)
self._increase_smnum(user.USid, clid, smnum, omnum, omstatus)
ordermain = OrderMain.create({
'OMid': omid,
'OMno': self._generic_omno(),
'USid': user.USid,
'UCid': ucid,
'OPayno': opayno,
'OMmount': mount,
'OMtrueMount': truemount,
'OMstatus': omstatus,
'OMrecvPhone': None,
'OMrecvName': None,
'OMrecvAddress': None,
'OMnum': omnum,
'SMid': smid,
'CLid': clid,
'CLname': clname,
'SMnum': smnum,
'OMtype': OrderMainType.setmeal.value,
'SMprice': trueunit
})
db.session.add(ordermain)
return clname, truemount
def _create_product_order(self, prid, omid, omnum, user, opayno, ua,
omrecvaddress, uc):
decimal_omnum = Decimal(omnum)
product = Products.query.filter(
Products.PRid == prid,
Products.PRstatus == ProductStatus.usual.value).first_('商品已售空')
mount = Decimal(
product.PRprice if product.PRprice else 0) * decimal_omnum
omintegral = int(
product.PRintegral if product.PRintegral else 0) * omnum
omintegralunit = product.PRvipIntegral if user.USlevel and product.PRvipIntegral else product.PRvipIntegral
omintegralpayed = int(omintegralunit if omintegralunit else 0) * omnum
if omintegralpayed:
if omintegralpayed > int(user.USintegral):
# todo 增加积分兑换规则
raise ParamsError('用户积分不足')
user.USintegral = int(user.USintegral) - omintegralpayed
# 创建积分修改记录
ui = UserIntegral.create({
'UIid': str(uuid.uuid1()),
'USid': user.USid,
'UIintegral': omintegralpayed,
'UIaction': PointTaskType.shopping_pay.value,
'UItype': 2,
'UItrue': 0,
})
# 积分消费流水
op_integral = OrderPay.create({
'OPayid': str(uuid.uuid1()),
'OPayno': opayno,
'OPayType': OrderPayType.integral.value,
'OPayMount': omintegralpayed,
})
db.session.add(ui)
db.session.add(op_integral)
db.session.add(user)
# todo Tips: 20200824 00:34
# 因无法对接his，暂时无法提供购买vip的服务；前端商城界面逻辑展示的会员价/原价，现行修改方案将vip价改为现价，商品按现价支付
# trueunit = product.PRvipPrice if user.USlevel and product.PRvipPrice else product.PRprice
trueunit = product.PRvipPrice if product.PRvipPrice else product.PRprice
truemount = (Decimal(trueunit)
if trueunit else Decimal(0)) * decimal_omnum
ucid = ''
if uc:
if uc.COdownline and truemount >= Decimal(uc.COdownline):
# 优惠后价格
truemount = truemount - Decimal(uc.COsubtration)
if truemount < Decimal(0):
truemount = Decimal(0)
uc.UCalreadyuse = CouponUserStatus.had_use.value
db.session.add(uc)
ucid = uc.UCid
else:
raise ParamsError('商品价格达不到优惠券最低金额')
omstatus = OrderMainStatus.wait_pay.value
if not truemount:
omstatus = OrderMainStatus.ready.value
content = ''
if product.COid and product.PRtype == ProductType.coupon.value:
# 优惠券商品 记录优惠券信息
coupon = Coupon.query.filter(Coupon.COid == product.COid,
Coupon.isdelete == 0).first_('商品已售空')
content = json.dumps(coupon, cls=JSONEncoder)
custatus = CouponUserStatus.cannot_use.value
if omstatus == OrderMainStatus.ready.value:
custatus = CouponUserStatus.not_use.value
model_list = []
for _ in range(omnum):
couponuser = CouponUser.create({
'UCid': str(uuid.uuid1()),
'COid': product.COid,
'USid': user.USid,
'COsubtration': coupon.COsubtration,
'COstarttime': coupon.COstarttime,
'COendtime': coupon.COendtime,
'COdownline': coupon.COdownline,
'UCalreadyuse': custatus,
'OMid': omid
})
model_list.append(couponuser)
db.session.add_all(model_list)
if product.CLid and product.PRtype == ProductType.package.value:
self._increase_smnum(user.USid, product.CLid, product.SMnum, omnum,
omstatus)
classes = Classes.query.filter(
Classes.CLid == product.CLid,
Classes.isdelete == 0).first_('商品已售空')
content = json.dumps(classes, cls=JSONEncoder)
# 库存修改
if product.PRstock < omnum:
raise ParamsError('商品库存不足')
product.PRstock -= omnum
om = OrderMain.create({
'OMid': omid,
'OMno': self._generic_omno(),
'USid': user.USid,
'UCid': ucid,
'OPayno': opayno,
'OMmount': mount,
'OMtrueMount': truemount,
'OMstatus': omstatus,
'OMrecvPhone': ua.UAtel,
'OMrecvName': ua.UAname,
'OMrecvAddress': omrecvaddress,
'OMintegralpayed': omintegralpayed,
'OMintegral': omintegral,
'PRid': prid,
'PRtype': product.PRtype,
'PRprice': product.PRprice,
'PRintegral': product.PRintegral,
'SMnum': product.SMnum,
'PRtitle': product.PRtitle,
'PRmedia': product.PRmedia,
'PRcontent': content,
'OMnum': omnum,
'OMtype': OrderMainType.product.value,
})
if truemount:
op_instance = OrderPay.create({
'OPayid': str(uuid.uuid1()),
'OPayno': opayno,
'OPayType': OrderPayType.wx.value,
'OPayMount': truemount,
})
db.session.add(op_instance)
db.session.add(om)
return product.PRtitle, truemount, omintegralpayed
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 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 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 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 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)
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_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)
