def set_linkcontent(self):
body = request.json
admin = Admin.query.filter(Admin.isdelete == false(),
Admin.ADid == getattr(request,
'user').id).first()
current_app.logger.info('当前管理员是 {}'.format(admin.ADname))
lcid = body.get('lcid')
lccontent = body.get('lccontent')
with db.auto_commit():
if lcid:
lc = LinkContent.query.filter(
LinkContent.LCid == lcid,
LinkContent.isdelete == False).first()
if body.get('delete'):
current_app.logger.info('开始删除富文本内容 lcid = {}'.format(lcid))
if not lc:
raise ParamsError('该内容已删除')
lc.isdelete = True
return Success('删除成功', data=lcid)
if lc:
current_app.logger.info('开始更新富文本内容 lcid = {}'.format(lcid))
if lccontent:
lc.LCcontent = lccontent
db.session.add(lc)
return Success('更新成功', data=lcid)
if not lccontent:
raise ParamsError('富文本内容不能为空')
lc = LinkContent.create({
'LCid': str(uuid.uuid1()),
'LCcontent': lccontent
})
current_app.logger.info('开始创建富文本内容 lcid = {}'.format(lc.LCid))
db.session.add(lc)
return Success('添加成功', data=lc.LCid)
def create_product(self):
"""创建商品"""
if is_admin():
product_from = ProductFrom.platform.value
elif is_supplizer():
product_from = ProductFrom.supplizer.value
else:
raise AuthorityError('当前用户无权进行该操作')
data = request.json
product_dict = self._validate_ticket_param(data)
if Product.query.filter(Product.isdelete == false(), Product.PRname == data.get('prname')).first():
raise ParamsError('该商品名称已存在')
with db.auto_commit():
product_dict.update({'PRid': str(uuid.uuid1()),
'CreatorId': getattr(request, 'user').id,
'CreatorType': getattr(request, 'user').model,
'PRname': data.get('prname'),
'PRimg': data.get('primg'),
'PRdetails': data.get('prdetails'),
# 'PRstatus': ProductStatus.ready.value if product_dict.get(
# 'PRtimeLimeted') else ProductStatus.active.value,
'PRstatus': ProductStatus.pending.value
})
product = Product.create(product_dict)
db.session.add(product)
# 0702 增加审批
# if product.PRtimeLimeted: # 限时商品，添加异步任务
# add_async_task(func=start_product, start_time=product.PRissueStartTime, func_args=(product.PRid,),
# conn_id='start_product{}'.format(product.PRid))
# add_async_task(func=end_product, start_time=product.PRissueEndTime, func_args=(product.PRid,),
# conn_id='end_product{}'.format(product.PRid))
self.base_approval.create_approval('toshelves', request.user.id, product.PRid, product_from)
self.base_admin.create_action(AdminActionS.insert.value, 'Product', product.PRid)
return Success('创建成功', data={'prid': product.PRid})
def list_product(self):
"""商品列表"""
args = request.args.to_dict()
filter_args = []
if not (is_admin() or is_supplizer()):
filter_args.append(Product.PRstatus.notin_((ProductStatus.interrupt.value, ProductStatus.reject.value,
ProductStatus.pending.value)))
if is_supplizer():
filter_args.append(Product.SUid == getattr(request, 'user').id)
prlimited = args.get('prtimelimeted')
if str(prlimited) in '01':
filter_args.append(Product.PRtimeLimeted == prlimited)
products = Product.query.filter(Product.isdelete == false(), *filter_args
).order_by(func.field(Product.PRstatus, ProductStatus.active.value,
ProductStatus.ready.value, ProductStatus.over.value),
Product.PRissueStartTime.asc(),
Product.createtime.desc()).all_with_page()
products_fields = ['PRid', 'PRname', 'PRimg', 'PRlinePrice', 'PRtruePrice', 'PRnum', 'PRtimeLimeted',
'PRstatus', 'prstatus_zh', 'apply_num', 'PRissueStartTime', 'PRissueEndTime',
'PRuseStartTime', 'PRuseEndTime', 'interrupt', 'apply_num_str', 'buyer_avatar',
'start_time_str']
for product in products:
self._fill_product(product)
product.fields = products_fields
if not product.PRtimeLimeted:
product.PRnum = '无限量'
return Success(data=products)
def get(self):
commision = Commision.query.filter(
Commision.isdelete == False, ).first()
commision.Levelcommision = json.loads(commision.Levelcommision)
commision.ReduceRatio = json.loads(commision.ReduceRatio)
commision.IncreaseRatio = json.loads(commision.IncreaseRatio)
return Success(data=commision)
def list_linkcontent(self):
lc_list = LinkContent.query.filter(
LinkContent.isdelete == False).order_by(
LinkContent.createtime.desc()).all_with_page()
for lc in lc_list:
self._fill_lc(lc)
return Success(data=lc_list)
def set_mp_banner(self):
"""小程序轮播图"""
data = parameter_required(('mpbpicture', ))
mpbid = data.get('mpbid')
mpb_dict = {
'MPBpicture': data.get('mpbpicture'),
'MPBsort': data.get('mpbsort'),
'MPBshow': data.get('mpbshow'),
'contentlink': data.get('contentlink')
}
with db.auto_commit():
if not mpbid:
mpb_dict['MPBid'] = str(uuid.uuid1())
mpb_dict['ADid'] = getattr(request, 'user').id
mpb_instance = MiniProgramBanner.create(mpb_dict)
# BASEADMIN().create_action(AdminActionS.insert.value, 'MiniProgramBanner', mpb_instance.MPBid)
msg = '添加成功'
else:
mpb_instance = MiniProgramBanner.query.filter_by_(
MPBid=mpbid).first_('未找到该轮播图信息')
if data.get('delete'):
mpb_instance.update({'isdelete': True})
# BASEADMIN().create_action(AdminActionS.delete.value, 'MiniProgramBanner', mpb_instance.MPBid)
msg = '删除成功'
else:
mpb_instance.update(mpb_dict, null='not')
# BASEADMIN().create_action(AdminActionS.update.value, 'MiniProgramBanner', mpb_instance.MPBid)
msg = '编辑成功'
db.session.add(mpb_instance)
return Success(message=msg, data={'mpbid': mpb_instance.MPBid})
def get_linkcontent(self):
data = parameter_required('lcid')
lcid = data.get('lcid')
lc = LinkContent.query.filter_by(LCid=lcid, isdelete=False).first()
if not lc:
raise ParamsError('链接失效')
return Success(data=lc)
def get_location(self):
"""获取定位"""
# user = get_current_user()
usid = getattr(request, 'user').id
data = parameter_required(('longitude', 'latitude'))
current_location = self.get_user_location(data.get('latitude'),
data.get('longitude'), usid)
return Success(data={'nelocation': current_location})
def list_activationtype(self):
data = parameter_required()
filter_args = {
ActivationType.isdelete == false()
}
# if data.get('atttype'):
# filter_args.add(ActivationType.ATTtype == data.get('atttype'))
att_list = ActivationType.query.filter(*filter_args).order_by(ActivationType.updatetime.desc()).all_with_page()
return Success(data=att_list)
def list_omstatus(self):
"""所有试用记录状态类型"""
res = [{'omstatus': k,
'omstatus_en': OrderStatus(k).name,
'omstatus_zh': OrderStatus(k).zh_value
} for k in (OrderStatus.pending.value, OrderStatus.has_won.value,
OrderStatus.completed.value, OrderStatus.cancle.value,
OrderStatus.not_won.value,)]
return Success(data=res)
def set_supplizeraccount(self):
if not is_supplizer():
raise AuthorityError
data = request.json
cardno = data.get('sacardno')
cardno = re.sub(r'\s', '', str(cardno))
self.cuser._CUser__check_card_num(cardno)
check_res = self.cuser._verify_cardnum(cardno) # 检验卡号
if not check_res.data.get('validated'):
raise ParamsError('请输入正确的银行卡号')
checked_res = self.cuser._verify_cardnum(data.get('sabankaccount'))
# if not checked_res.data.get('validated'):
# raise ParamsError('请输入正确的开票账户银行卡号')
checked_name = self.cuser._verify_chinese(data.get('sacardname'))
if not checked_name or len(checked_name[0]) < 2:
raise ParamsError('请输入正确的开户人姓名')
current_app.logger.info('用户输入银行名为:{}'.format(data.get('sabankname')))
bankname = check_res.data.get('cnbankname')
try:
WexinBankCode(bankname)
except Exception:
raise ParamsError('系统暂不支持该银行提现，请更换银行后重新保存')
data['sabankname'] = bankname
current_app.logger.info('校验后更改银行名为:{}'.format(data.get('sabankname')))
sa = SupplizerAccount.query.filter(
SupplizerAccount.SUid == request.user.id,
SupplizerAccount.isdelete == false()).first()
if sa:
for key in sa.__dict__:
if str(key).lower() in data:
if re.match(r'^(said|suid)$', str(key).lower()):
continue
if str(key).lower() == 'sacardno':
setattr(sa, key, cardno)
continue
setattr(sa, key, data.get(str(key).lower()))
else:
sa_dict = {}
for key in SupplizerAccount.__dict__:
if str(key).lower() in data:
if not data.get(str(key).lower()):
continue
if str(key).lower() == 'suid':
continue
if str(key).lower() == 'sacardno':
sa_dict.setdefault(key, cardno)
continue
sa_dict.setdefault(key, data.get(str(key).lower()))
sa_dict.setdefault('SAid', str(uuid.uuid1()))
sa_dict.setdefault('SUid', request.user.id)
sa = SupplizerAccount.create(sa_dict)
db.session.add(sa)
return Success('设置供应商账户信息成功')
def get_approvalnotes(self):
"""查看审批的所有流程"""
if not (is_admin() or is_supplizer()):
raise AuthorityError('权限不足')
data = parameter_required(('avid', ))
an_list = ApprovalNotes.query.filter_by_(
AVid=data.get('avid')).order_by(ApprovalNotes.createtime).all()
for an in an_list:
an.fill('anaction', ApprovalAction(an.ANaction).zh_value)
return Success('获取审批记录成功', data=an_list)
def update_role(self):
data = parameter_required('amtype')
# amtype = int(data.get('amtype', 0) or 0)
with db.auto_commit():
amtype = self._check_roletype(data.get('amtype', 0))
role = Agreement.query.filter_by(AMtype=amtype,
isdelete=False).first()
if not role:
raise ParamsError('规则失效')
role.AMcontent = data.get('amcontent')
return Success('更新成功')
def list_mp_banner(self):
"""小程序轮播图获取"""
filter_args = []
if not is_admin():
filter_args.append(MiniProgramBanner.MPBshow == true())
mpbs = MiniProgramBanner.query.filter(
MiniProgramBanner.isdelete == false(),
*filter_args).order_by(MiniProgramBanner.MPBsort.asc(),
MiniProgramBanner.createtime.desc()).all()
[x.hide('ADid') for x in mpbs]
return Success(data=mpbs)
def get_dealing_approval(self):
"""管理员查看自己名下可以处理的审批流 概览"""
if is_admin():
admin = Admin.query.filter_by_(
ADid=request.user.id).first_('管理员账号已被回收')
if not admin:
current_app.logger.info('get admin failed id is {0}'.format(
admin.ADid))
raise NotFound("该管理员已被删除")
# pttype = request.args.to_dict().get('pttypo')
pt_list = PermissionType.query.filter(
PermissionType.PTid == Permission.PTid,
Permission.PIid == AdminPermission.PIid,
AdminPermission.ADid == admin.ADid,
PermissionType.isdelete == False,
AdminPermission.isdelete == False,
Permission.isdelete == False).order_by(
PermissionType.createtime.desc()).all()
# pi_list = AdminPermission.query.filter_by_(ADid=admin.ADid).all()
for pt in pt_list:
ap_num = Approval.query.filter(
Approval.PTid == pt.PTid,
Approval.AVlevel == Permission.PELevel,
Permission.PTid == pt.PTid,
Permission.PIid == AdminPermission.PIid,
AdminPermission.ADid == admin.ADid,
Approval.AVstatus == ApplyStatus.wait_check.value,
Approval.isdelete == False, Permission.isdelete == False,
AdminPermission.isdelete == False).count()
pt.fill('approval_num', ap_num)
elif is_supplizer():
sup = Supplizer.query.filter_by_(
SUid=request.user.id).first_('供应商账号已回收')
pt_list = PermissionType.query.filter(
PermissionType.PTid == Approval.PTid,
Approval.AVstartid == sup.SUid,
Approval.AVstatus == ApplyStatus.wait_check.value,
PermissionType.isdelete == False,
Approval.isdelete == False).all()
if not pt_list:
pt_list = PermissionType.query.filter_by_(
PTid='tointegral').all()
# todo 供应商的审批类型筛选
for pt in pt_list:
ap_num = Approval.query.filter(
Approval.AVstartid == sup.SUid, Approval.PTid == pt.PTid,
Approval.isdelete == False).count()
pt.fill('approval_num', ap_num)
else:
pt_list = []
return Success('获取审批流类型成功', data=pt_list)
def get(self):
data = parameter_required('omid')
omid = data.get('omid')
filter_args = [OrderMain.OMid == omid, OrderMain.isdelete == false()]
if is_user():
filter_args.append(OrderMain.USid == getattr(request, 'user').id)
om = OrderMain.query.filter(*filter_args).first_('订单不存在')
user = User.query.filter(User.isdelete == false(), User.USid == om.USid).first_('订单信息错误')
self._fill_ordermain(om)
om.fill('usname', user.USname)
om.fill('usheader', user['USheader'])
return Success(data=om)
def get_verifier(self):
form = GetVerifier().valid_data()
suid = form.suid.data
if is_supplizer():
suid = request.user.id
if not suid:
raise ParamsError('未指定供应商')
tv_list = ProductVerifier.query.filter_by(
SUid=suid,
isdelete=False).order_by(ProductVerifier.createtime.desc()).all()
phone_list = [tv.PVphone for tv in tv_list]
return Success(data=phone_list)
def offshelves(self):
current_app.logger.info('下架供应商')
data = parameter_required(('suid', ))
suid = data.get('suid')
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == suid).first_('供应商不存在')
supplizer.SUstatus = UserStatus.forbidden.value
db.session.add(supplizer)
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', suid)
return Success('供应商下架成功')
def get_product(self):
"""商品详情"""
args = parameter_required(('prid',))
prid = args.get('prid')
secret_usid = args.get('secret_usid')
if secret_usid: # 创建邀请记录
self._invitation_record(secret_usid, args)
product = Product.query.filter(Product.isdelete == false(), Product.PRid == prid).first_('商品已下架')
self._fill_product(product)
month_sale_value = self._fill_month_sale_value(prid)
product.fill('month_sale_value', month_sale_value)
return Success(data=product)
def _list_ticket_sup():
sups = Supplizer.query.filter(
Supplizer.isdelete == false(),
Supplizer.SUstatus == UserStatus.usual.value,
Supplizer.SUgrade == SupplizerGrade.ticket.value)
if is_supplizer():
sups = sups.filter(Supplizer.SUid == getattr(request, 'user').id)
sups = sups.all_with_page()
for sup in sups:
sup.fields = ['SUid', 'SUname', 'SUgrade', 'SUstatus']
sup.fill('sustatus_zh', UserStatus(sup.SUstatus).zh_value)
sup.fill('sugrade_zh', SupplizerGrade(sup.SUgrade).zh_value)
return Success(data=sups)
def remove(self):
data = parameter_required(('img_url',))
try:
img_url = data.get('img_url')
dirs = img_url.split('/')[-6:]
name_shuffer = dirs[-1]
name = name_shuffer.split('.')[0]
if not 'anonymous' in name and request.user.id not in name:
raise NotFound()
path = os.path.join(current_app.config['BASEDIR'], '/'.join(dirs))
os.remove(path)
except Exception as e:
raise NotFound()
return Success(u'删除成功')
def cancle(self):
"""付款前取消订单"""
data = parameter_required(('omid',))
omid = data.get('omid')
if not is_user():
raise AuthorityError
usid = getattr(request, 'user').id
order_main = OrderMain.query.filter(
OrderMain.OMid == omid, OrderMain.USid == usid, OrderMain.isdelete == false()).first_('指定订单不存在')
# if is_supplizer() and order_main.PRcreateId != usid:
# raise AuthorityError()
# if not is_admin() and order_main.USid != usid:
# raise NotFound('订单订单不存在')
self._cancle(order_main)
return Success('取消成功')
def get_duration_activation(self):
data = parameter_required('tistarttime', 'tiendtime')
if is_admin():
usid = data.get('usid')
elif is_user():
usid = getattr(request, 'user').id
else:
raise AuthorityError('请登录')
start = self._trans_time(data.get('tistarttime'))
end = self._trans_time(data.get('tiendtime'))
at_list = Activation.query.filter(
Activation.USid == usid, Activation.createtime >= start, Activation.createtime <= end).all_with_page()
for at in at_list:
self._fill_at(at)
return Success(data=at_list)
def product_verified(self):
"""商品核销"""
data = parameter_required('param')
param = data.get('param')
try:
omid, secret_usid = str(param).split('&')
if not omid.startswith('omid'):
raise ValueError
except ValueError:
raise ParamsError('该二维码无效')
current_app.logger.info('omid: {}, secret_usid: {}'.format(omid, secret_usid))
omid = str(omid).split('=')[-1]
secret_usid = str(secret_usid).split('=')[-1]
current_app.logger.info('splited, omid: {}, secret_usid: {}'.format(omid, secret_usid))
if not omid or not secret_usid:
raise StatusError('该试用码无效')
ticket_usid = self.cuser._base_decode(secret_usid)
ticket_user = User.query.filter(User.isdelete == false(),
User.USid == ticket_usid).first_('无效试用码')
om = OrderMain.query.filter(OrderMain.isdelete == false(),
OrderMain.OMid == omid).first_('订单状态异常')
if om.OMstatus != OrderStatus.has_won.value:
current_app.logger.error('om status: {}'.format(om.TSOstatus))
raise StatusError('提示：该二维码已被核销过')
pr = Product.query.filter(Product.PRid == om.PRid).first()
if pr.PRtimeLimeted and (pr.PRuseStartTime <= datetime.now() <= pr.PRuseEndTime):
raise StatusError('当前时间不在该券有效使用时间内')
user = User.query.join(ProductVerifier, ProductVerifier.PVphone == User.UStelephone
).join(Product, Product.SUid == ProductVerifier.SUid
).filter(User.isdelete == false(), User.USid == getattr(request, 'user').id,
ProductVerifier.SUid == pr.SUid
).first_('请确认您是否拥有该券的核销权限')
with db.auto_commit():
# 订单改状态
om.update({'OMstatus': OrderStatus.completed.value})
db.session.add(om)
# 核销记录
tvr = ProductVerifiedRecord.create({'PVRid': str(uuid.uuid1()),
'ownerId': ticket_user.USid,
'VerifierId': user.USid,
'OMid': om.OMid,
'param': param})
db.session.add(tvr)
return Success('二维码验证成功', data=tvr.PVRid)
def get(self):
if not is_admin() and not is_supplizer():
raise AuthorityError()
form = SupplizerGetForm().valid_data()
supplizer = form.supplizer
self._fill_supplizer(supplizer)
# pbs = ProductBrand.query.filter(
# ProductBrand.isdelete == False,
# ProductBrand.SUid == supplizer.SUid
# ).all()
# for pb in pbs:
# if pb:
# pb.pbstatus_zh = ProductBrandStatus(pb.PBstatus).zh_value
# pb.add('pbstatus_zh')
supplizer.fill('pbs', [])
supplizer.fill('SUbaseRate', 0)
return Success(data=supplizer)
def update(self):
"""更新供应商信息"""
if not is_admin() and not is_supplizer():
raise AuthorityError()
form = SupplizerUpdateForm().valid_data()
pbids = form.pbids.data
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == form.suid.data).first_('供应商不存在')
supplizer_dict = {
'SUlinkPhone': form.sulinkphone.data,
'SUname': form.suname.data,
'SUlinkman': form.sulinkman.data,
'SUaddress': form.suaddress.data,
'SUbanksn': form.subanksn.data,
'SUbankname': form.subankname.data,
# 'SUpassword': generate_password_hash(form.supassword.data), # 暂时去掉
'SUheader': form.suheader.data,
'SUcontract': form.sucontract.data,
'SUbusinessLicense': form.subusinesslicense.data,
'SUregisteredFund': form.suregisteredfund.data,
'SUmainCategory': form.sumaincategory.data,
# 'SUregisteredTime': form.suregisteredtime.data,
'SUlegalPerson': form.sulegalperson.data,
'SUemail': form.suemail.data,
'SUlegalPersonIDcardFront': form.sulegalpersonidcardfront.data,
'SUlegalPersonIDcardBack': form.sulegalpersonidcardback.data,
}
if is_admin():
# if form.subaserate.data:
# supplizer_dict['SUbaseRate'] = form.subaserate.data,
if isinstance(form.sustatus.data, int):
supplizer_dict['SUstatus'] = form.sustatus.data
if form.sustatus.data == UserStatus.usual.value and not supplizer.SUpassword:
supplizer_dict['SUpassword'] = generate_password_hash(
supplizer.SUloginPhone)
supplizer.update(supplizer_dict, null='dont ignore')
db.session.add(supplizer)
if is_admin():
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', form.suid.data)
return Success('更新成功')
def get_promotion(self):
data = parameter_required('prid')
user = User.query.filter(User.isdelete == false(), User.USid == getattr(request, 'user').id).first_('请重新登录')
prid = data.get('prid')
params = data.get('params')
product = Product.query.filter(
Product.PRid == prid, Product.PRstatus < ProductStatus.interrupt.value,
Product.isdelete == false()).first_('活动已结束')
usid = user.USid
starttime = endtime = starttime_g = endtime_g = None
if product.PRtimeLimeted:
starttime = self._check_time(product.PRuseStartTime)
endtime = self._check_time(product.PRuseEndTime, fmt='%m/%d')
starttime_g = self._check_time(product.PRissueStartTime)
endtime_g = self._check_time(product.PRissueEndTime, fmt='%m/%d')
# 获取微信二维码
from ..control.CUser import CUser
cuser = CUser()
if not params or 'page=' not in params:
params = 'page=/pages/index/freeDetail'
if 'prid' not in params:
params = '{}&prid={}'.format(params, prid)
if 'secret_usid' not in params:
params = '{}&secret_usid={}'.format(params, cuser._base_encode(usid))
params = '{}&sttype={}'.format(params, ShareType.promotion.value)
params_key = cuser.shorten_parameters(params, usid, 'params')
wxacode_path = cuser.wxacode_unlimit(
usid, {'params': params_key}, img_name='{}{}'.format(usid, prid), is_hyaline=True)
local_path, promotion_path = PlayPicture().create_ticket(
product.PRimg, product.PRname, str(0), usid, prid, wxacode_path, product.PRlinePrice,
product.PRtruePrice, starttime, endtime, starttime_g, endtime_g)
CFile().upload_to_oss(local_path, promotion_path[1:], '商品推广图')
scene = cuser.dict_to_query_str({'params': params_key})
current_app.logger.info('get scene = {}'.format(scene))
return Success(data={
'promotion_path': promotion_path,
'scene': scene
})
def set_verifier(self):
form = SetVerifier().valid_data()
if is_admin():
suid = form.suid.data
assert suid, '供应商未指定'
elif is_supplizer():
suid = request.user.id
else:
raise AuthorityError()
sup = Supplizer.query.filter(
Supplizer.isdelete == false(),
Supplizer.SUstatus == UserStatus.usual.value,
Supplizer.SUid == suid).first_('供应商状态异常')
if sup.SUgrade != SupplizerGrade.ticket.value:
raise StatusError('仅虚拟商品供应商可设置核销员')
phone_list = form.phone_list.data
tvid_list = []
instence_list = []
phone_list = {}.fromkeys(phone_list).keys()
with db.auto_commit():
for phone in phone_list:
User.query.filter(
User.isdelete == false(),
User.UStelephone == phone).first_(f'没有手机号为 {phone} 用户 ')
tv = ProductVerifier.query.filter_by(SUid=suid,
PVphone=phone).first()
if not tv:
tv = ProductVerifier.create({
'PVid': str(uuid.uuid1()),
'SUid': suid,
'PVphone': phone
})
instence_list.append(tv)
tvid_list.append(tv.PVid)
db.session.add_all(instence_list)
# 删除无效的
ProductVerifier.query.filter(
ProductVerifier.isdelete == false(),
ProductVerifier.SUid == suid,
ProductVerifier.PVid.notin_(tvid_list)).delete_(
synchronize_session=False)
return Success('修改成功', data=suid)
def change_password(self):
if not is_supplizer() and not is_admin():
raise AuthorityError()
form = SupplizerChangePasswordForm().valid_data()
old_password = form.oldpassword.data
supassword = form.supassword.data
suid = form.suid.data
with db.auto_commit():
supplizer = Supplizer.query.filter(
Supplizer.isdelete == False,
Supplizer.SUid == suid).first_('不存在的供应商')
if not is_admin() and not check_password_hash(
supplizer.SUpassword, old_password):
raise AuthorityError('原密码错误')
supplizer.SUpassword = generate_password_hash(supassword)
db.session.add(supplizer)
if is_admin():
self.base_admin.create_action(AdminActionS.update.value,
'Supplizer', suid)
return Success('修改成功')
def update_activationtype(self):
data = parameter_required('attid')
attid = data.pop('attid')
with db.auto_commit():
att = ActivationType.query.filter_by(ATTid=attid, isdelete=False).first_('活跃度获取方式未被记录')
admin = Admin.query.filter(
Admin.ADid == getattr(request, 'user').id, Admin.isdelete == false()).first_('用户信息有误')
update_dict = {
'ADid': admin.ADid
}
for key in att.keys():
lower_key = str(key).lower()
value = data.get(lower_key)
if value or value == 0:
if key != 'ATTname' and not str(value).isdigit():
raise ParamsError('{} 只能是自然数'.format(getattr(ActivationType, key).comment))
update_dict.setdefault(key, value)
att.update(update_dict)
db.session.add(att)
return Success('修改成功', data=attid)
