420 lines
20 KiB
Plaintext
420 lines
20 KiB
Plaintext
async def productSort(data, flag=None):
|
|
if flag == 'discount':
|
|
current_date = datetime.datetime.now().date()
|
|
sorted_data = sorted(data, key=lambda x: (x['start_date']))
|
|
result = []
|
|
exits_id = []
|
|
for item in sorted_data:
|
|
start_date = datetime.datetime.strptime(item['start_date'], '%Y-%m-%d').date()
|
|
end_date = datetime.datetime.strptime(item['end_date'], '%Y-%m-%d').date()
|
|
if start_date <= current_date <= end_date:
|
|
result.append(item)
|
|
exits_id.append(item['productid'])
|
|
for info in sorted_data:
|
|
if not info['productid'] in exits_id:
|
|
result.append(info)
|
|
exits_id.append(info['productid'])
|
|
return result
|
|
|
|
elif flag == 'floorprice':
|
|
current_date = datetime.datetime.now().date()
|
|
sorted_data = sorted(data, key=lambda x: (x['begin_date']))
|
|
result = []
|
|
exits_id = []
|
|
for item in sorted_data:
|
|
start_date = datetime.datetime.strptime(item['begin_date'], '%Y-%m-%d').date()
|
|
end_date = datetime.datetime.strptime(item['end_date'], '%Y-%m-%d').date()
|
|
if start_date <= current_date <= end_date:
|
|
if not item['productid'] in exits_id:
|
|
result.append(item)
|
|
exits_id.append(item['productid'])
|
|
for info in sorted_data:
|
|
if not info['productid'] in exits_id:
|
|
result.append(info)
|
|
exits_id.append(info['productid'])
|
|
return result
|
|
|
|
elif flag == 'rebate':
|
|
current_date = datetime.datetime.now().date()
|
|
sorted_data = sorted(data, key=lambda x: (x['start_date']))
|
|
result = []
|
|
exits_id = []
|
|
for item in sorted_data:
|
|
start_date = datetime.datetime.strptime(item['start_date'], '%Y-%m-%d').date()
|
|
end_date = datetime.datetime.strptime(item['end_date'], '%Y-%m-%d').date()
|
|
if start_date <= current_date <= end_date:
|
|
if not item['productid'] in exits_id:
|
|
result.append(item)
|
|
exits_id.append(item['productid'])
|
|
for info in sorted_data:
|
|
if not info['productid'] in exits_id:
|
|
result.append(info)
|
|
exits_id.append(info['productid'])
|
|
return result
|
|
|
|
# sorted_data = sorted(data, key=lambda x: (x['sale_amount']))
|
|
# result = {'0':[], '1':[], '2':[], '3':[], '4':[], '5':[]}
|
|
# for rap in sorted_data:
|
|
# productid = rap.get('rebate_cycle')
|
|
# if productid not in list(result.keys()):
|
|
# result[productid] = []
|
|
# result[productid].append(rap)
|
|
# return sorted_data
|
|
|
|
async def getConfigProduct(ns={}, sor=None):
|
|
"""
|
|
根据resellerid获取配置过折扣回佣底价的产品
|
|
:return:
|
|
"""
|
|
exits_product = []
|
|
# filter rp_discount
|
|
# 加上分页会影响结果 取消分页 limit 200 offset 0;
|
|
discount_sql = """SELECT rd.*, p.providerid, p.providerpid, p.name, p.description, p.ptype, p.state,
|
|
p.effect_date, p.expire_date, p.salemode, p.product_code, p.spec_note, p.product_area,
|
|
p.specific_pattern, p.reseller_orgid FROM rp_discount AS rd LEFT JOIN product AS p ON rd.productid=p.id
|
|
where resellerid = '%s' and rd.del_flg = '0';""" % ns.get('resellerid')
|
|
discount_res_rows = await sor.sqlExe(discount_sql, {})
|
|
discount_res_rows_sort = await productSort(discount_res_rows, flag='discount')
|
|
for discount in discount_res_rows:
|
|
exits_product.append(discount.get('productid'))
|
|
|
|
# filter rp_rebate
|
|
rebate_sql = """select rb.*, p.providerid, p.providerpid, p.name, p.description, p.ptype, p.state,
|
|
p.effect_date, p.expire_date, p.salemode, p.product_code, p.spec_note,
|
|
p.product_area, p.specific_pattern, p.reseller_orgid from (select tl.*, te.id as rebate_tableid,
|
|
te.rebate_cycle, te.sale_amount, te.rebate_rate from rp_rebate_ctl as tl LEFT JOIN rp_rebate as te on
|
|
tl.rebateid=te.rebateid where tl.resellerid = '%s' and tl.del_flg = '0') as rb LEFT JOIN product
|
|
as p on rb.productid=p.id;""" % ns.get('resellerid')
|
|
rebate_res_list = await sor.sqlExe(rebate_sql, {})
|
|
rebate_res_rows_sort = await productSort(rebate_res_list, flag='rebate')
|
|
for rebate in rebate_res_list:
|
|
exits_product.append(rebate.get('productid'))
|
|
|
|
# filter floorprice
|
|
floor_sql = """select fl.*, p.providerid, p.providerpid, p.name, p.description, p.ptype, p.state,
|
|
p.effect_date, p.expire_date, p.salemode, p.product_code,
|
|
p.spec_note, p.product_area, p.specific_pattern, p.reseller_orgid FROM floorprice as fl
|
|
LEFT JOIN product as p on fl.productid=p.id where fl.bid_orgid='%s'
|
|
and fl.del_flg='0';""" % (ns.get('resellerid'))
|
|
floorprice_res_rows = await sor.sqlExe(floor_sql, {})
|
|
floorprice_res_rows_sort = await productSort(floorprice_res_rows, flag='floorprice')
|
|
for floor in floorprice_res_rows_sort:
|
|
exits_product.append(floor.get('productid'))
|
|
|
|
return exits_product, discount_res_rows_sort, rebate_res_rows_sort, floorprice_res_rows_sort
|
|
|
|
async def providerSearch(ns={}):
|
|
"""
|
|
add new provider
|
|
`name`: 名称,
|
|
`description`: 描述,
|
|
`appid`: 应用id,
|
|
`providerkey`: 应用key,
|
|
`state`: 状态,
|
|
`start_date`: 起效日期,
|
|
`end_date`: 失效日期,
|
|
`sale_mode`: 销售方式,
|
|
`del_flag`: 删除标志
|
|
:param ns:
|
|
:return:
|
|
"""
|
|
kv = ns.get('kv')
|
|
userid = await get_user()
|
|
db = DBPools()
|
|
async with db.sqlorContext('kboss') as sor:
|
|
try:
|
|
if userid:
|
|
orgid_li = await sor.R('users', {'id': userid, 'del_flg': '0'})
|
|
ns['orgid'] = orgid_li[0].get('orgid')
|
|
|
|
# 获取本机构自己的供应商
|
|
ns_org_provider = {
|
|
'parentid': ns.get('orgid'),
|
|
'org_type': '4',
|
|
'del_flg': '0',
|
|
'sort': 'create_at',
|
|
'order': 'desc',
|
|
'page': ns.get('page') if ns.get('page') else 1
|
|
}
|
|
org_li = await sor.R('organization', ns_org_provider)
|
|
org_li_rows = org_li.get('rows')
|
|
provider_list = []
|
|
for org in org_li_rows:
|
|
org_id = org.get('id')
|
|
provider_li = await sor.R('provider', {'orgid': org_id, 'del_flg': '0'})
|
|
provider_detail = provider_li[0] if provider_li else {}
|
|
if provider_detail:
|
|
if provider_detail.get('discount_mode'):
|
|
provider_detail['salemode'] = 0
|
|
elif provider_detail.get('rebate_mode'):
|
|
provider_detail['salemode'] = 1
|
|
elif provider_detail.get('floorprice_mode'):
|
|
provider_detail['salemode'] = 2
|
|
# 查找saleprotocol表 返回protocolid
|
|
saleprotocol_id_li = await sor.R('saleprotocol', {'offer_orgid': org_id, 'bid_orgid': ns.get('orgid')})
|
|
if saleprotocol_id_li:
|
|
provider_detail['protocolid'] = saleprotocol_id_li[0]['id']
|
|
provider_detail['salemode'] = saleprotocol_id_li[0]['salemode']
|
|
# provider_detail['settle_mode'] = saleprotocol_id_li[0]['settle_mode']
|
|
provider_detail['settle_datep'] = saleprotocol_id_li[0]['settle_dp']
|
|
provider_detail['protocolfile'] = saleprotocol_id_li[0]['protocolfile']
|
|
provider_detail['provider_table_id'] = provider_detail.pop('id')
|
|
org.update(provider_detail)
|
|
provider_list.append(org)
|
|
|
|
# TODO 获取上级机构提供的供应商
|
|
# superior_res = await superior_org_provider_search({'user_org_id': ns.get('orgid')})
|
|
|
|
# 通过协议筛选
|
|
if kv == 'discount':
|
|
provider_list = [item for item in provider_list if str(item.get('salemode')) in ['0', '1']]
|
|
elif kv == 'price':
|
|
provider_list = [item for item in provider_list if str(item.get('salemode')) in ['2']]
|
|
return {
|
|
"status": True,
|
|
"msg": "provider search success",
|
|
"data": provider_list
|
|
}
|
|
except Exception as e:
|
|
raise e
|
|
return {
|
|
"status": False,
|
|
"msg": "provider search failed",
|
|
"data": ""
|
|
}
|
|
|
|
|
|
async def productSearch(ns={}):
|
|
"""
|
|
search product
|
|
if ns is None, return all product
|
|
Can be queried using separate fields
|
|
引用函数
|
|
providerSearch.dspy
|
|
superior_org_provider_search.dspy
|
|
:param ns:
|
|
:return:
|
|
"""
|
|
db = DBPools()
|
|
async with db.sqlorContext('kboss') as sor:
|
|
try:
|
|
ns['del_flg'] = '0'
|
|
ns['sort'] = 'create_at'
|
|
ns['order'] = 'desc'
|
|
ns['page'] = ns.get('page', 1)
|
|
|
|
if ns.get('organizationid'):
|
|
kv = ns.get('kv')
|
|
provider_product_all = []
|
|
|
|
# 获取本机构自己的供应商
|
|
owner_providers = (await providerSearch({'orgid': ns.get('organizationid')}))['data']
|
|
# 获取本机构供应商的所有产品
|
|
for provider in owner_providers:
|
|
providerid = provider['id']
|
|
products_li = await sor.R('product', {'providerid': providerid, 'del_flg': '0'})
|
|
# 过滤折扣回佣底价
|
|
provider['product'] = products_li
|
|
provider_product_all.append(provider)
|
|
# TODO 获取本机构上级机构供应商和所有产品类型
|
|
# superiors = await superior_org_provider_search({'user_org_id': ns.get('organizationid'), 'sor': sor})
|
|
cc = {}
|
|
bb = {}
|
|
for item in provider_product_all:
|
|
providerid = item['id']
|
|
providername = item['name']
|
|
for pty in item['product']:
|
|
ptype = pty['ptype']
|
|
if providername in cc.keys():
|
|
ptypes = cc[providername]['ptype']
|
|
if not ptype in ptypes:
|
|
ptypes.append(ptype)
|
|
cc[providername]['ptype'] = ptypes
|
|
else:
|
|
bb[providername] = {'providerid': providerid, 'ptype': [ptype]}
|
|
cc.update(bb)
|
|
yugo_list = []
|
|
for yugo in cc.keys():
|
|
yugo_dic = {}
|
|
yugo_dic['providername'] = yugo
|
|
yugo_dic['providerid'] = cc[yugo]['providerid']
|
|
yugo_dic['ptype'] = cc[yugo]['ptype']
|
|
yugo_list.append(yugo_dic)
|
|
if ns.get('providerid'):
|
|
# 找到对应供应商的ptype
|
|
for daer in yugo_list:
|
|
daer_providerid = daer['providerid']
|
|
if daer_providerid == ns.get('providerid'):
|
|
ptypes = daer['ptype']
|
|
return {
|
|
'status': True,
|
|
'msg': '获取供应商对应的产品类型成功',
|
|
'data': ptypes
|
|
}
|
|
if kv == 'ptype':
|
|
# 找所有ptype
|
|
all_ptype = []
|
|
for juli in yugo_list:
|
|
juli_ptype = juli['ptype']
|
|
all_ptype.extend(juli_ptype)
|
|
return {
|
|
'status': True,
|
|
'msg': '获取所有产品类型成功',
|
|
'data': all_ptype
|
|
}
|
|
return {
|
|
'status': True,
|
|
'msg': '获取所有供应商成功',
|
|
'data': yugo_list
|
|
}
|
|
# orgid是查找供应商和上级机构给的产品 resellerid是查找设置过折扣回佣底价的产品
|
|
if ns and ns.get('resellerid') and ns.get('orgid'):
|
|
# 查找已经给该分销商配置过的产品
|
|
exits_product, discount_res_rows_sort, rebate_res_rows_sort, floorprice_res_rows_sort = \
|
|
await getConfigProduct({'resellerid': ns.get('resellerid')}, sor)
|
|
|
|
# 查找供应商和上级机构给的产品
|
|
# 查找供应商提供的产品
|
|
provider_res_list = await sor.R('product', {'reseller_orgid': ns.get('orgid'), 'del_flg': '0'})
|
|
|
|
# 查找上级机构提供的产品
|
|
exits_provider_product, discount_provider_sort, rebate_provider_sort, floorprice_provider_sort = \
|
|
await getConfigProduct(ns, sor)
|
|
if exits_provider_product:
|
|
prd_tuple = tuple(exits_provider_product)
|
|
all_product_set = ', '.join(list(map(lambda x: "'%s'", exits_provider_product)))
|
|
product_all_sql = """select * from product WHERE id in (%s) and del_flg='0';""" % all_product_set
|
|
product_all_list = await sor.sqlExe(product_all_sql % prd_tuple, {})
|
|
provider_res_list.extend(product_all_list)
|
|
|
|
# 筛选已经配置过的产品 获取no_cofig
|
|
product_res = []
|
|
for product in provider_res_list:
|
|
productid = product.get('id')
|
|
if productid not in exits_product:
|
|
product_res.append(product)
|
|
result = {
|
|
'discount': {'rows': discount_res_rows_sort},
|
|
'rebate': rebate_res_rows_sort,
|
|
'floorprice': {'rows': floorprice_res_rows_sort},
|
|
'no_config': product_res
|
|
}
|
|
return {
|
|
"status": True,
|
|
"msg": "reseller product search success",
|
|
"data": result
|
|
}
|
|
elif ns and ns.get('providerid'):
|
|
prd_list = []
|
|
prd_result = await sor.R('product',ns)
|
|
if not prd_result:
|
|
return {
|
|
'status': False,
|
|
'msg': 'get product from provider: % is null' % ns.get('providerid')
|
|
}
|
|
if 0:
|
|
# 价格从底价表或供应商那里获取
|
|
for prd in prd_result.get('rows'):
|
|
prd_id = prd.get('id')
|
|
fl_find = {
|
|
'productid': prd_id,
|
|
'offer_orgid': ns.get('providerid'),
|
|
'bid_orgid': ns.get('orgid'),
|
|
'del_flg': '0'
|
|
}
|
|
floor_dict = {}
|
|
selling_dict = {}
|
|
floor_price_li = await sor.R('floorprice', fl_find)
|
|
if floor_price_li:
|
|
floor_price = floor_price_li[0]
|
|
floor_dict = {
|
|
'floor_price': floor_price.get('price'),
|
|
'floor_begin_date': floor_price.get('begin_date'),
|
|
'floor_end_date': floor_price.get('end_date')
|
|
}
|
|
|
|
sel_find = {
|
|
'productid': prd_id,
|
|
'offer_orgid': ns.get('orgid'),
|
|
'bid_orgid': '',
|
|
'del_flg': '0'
|
|
}
|
|
selling_price_li = await sor.R('floorprice', sel_find)
|
|
if selling_price_li:
|
|
selling_price = selling_price_li[0]
|
|
selling_dict = {
|
|
'selling_price': selling_price.get('price'),
|
|
'selling_begin_date': selling_price.get('begin_date'),
|
|
'selling_end_date': selling_price.get('end_date')
|
|
}
|
|
if floor_dict and selling_dict:
|
|
prd.update(floor_dict)
|
|
prd.update(selling_dict)
|
|
prd_list.append(prd)
|
|
return {
|
|
"status": True,
|
|
"msg": "product search success",
|
|
"data": prd_result
|
|
}
|
|
# 产品管理 上级机构给当前机构设置过的产品 查找
|
|
elif ns.get('orgid'):
|
|
orgid = ns.get('orgid')
|
|
res_list = []
|
|
discount_sql = """SELECT rd.*, p.providerid, p.providerpid, p.name, p.description, p.ptype, p.state,
|
|
p.effect_date, p.expire_date, p.salemode, p.product_code, p.spec_note, p.product_area,
|
|
p.specific_pattern, p.reseller_orgid FROM rp_discount AS rd LEFT JOIN product AS p ON rd.productid=p.id
|
|
where resellerid = '%s' and rd.del_flg = '0';""" % orgid
|
|
discount_res_rows = await sor.sqlExe(discount_sql, {})
|
|
discount_res_rows_sort = await productSort(discount_res_rows, flag='discount')
|
|
|
|
# filter rp_rebate
|
|
rebate_sql = """select rb.*, p.providerid, p.providerpid, p.name, p.description, p.ptype, p.state,
|
|
p.effect_date, p.expire_date, p.salemode, p.product_code, p.spec_note,
|
|
p.product_area, p.specific_pattern, p.reseller_orgid from (select tl.*, te.id as rebate_tableid,
|
|
te.rebate_cycle, te.sale_amount, te.rebate_rate from rp_rebate_ctl as tl LEFT JOIN rp_rebate as te on
|
|
tl.rebateid=te.rebateid where tl.resellerid = '%s' and tl.del_flg = '0') as rb LEFT JOIN product
|
|
as p on rb.productid=p.id;""" % orgid
|
|
rebate_res_list = await sor.sqlExe(rebate_sql, {})
|
|
rebate_res_rows_sort = await productSort(rebate_res_list, flag='rebate')
|
|
|
|
# filter floorprice
|
|
floor_sql = """select fl.*, p.providerid, p.providerpid, p.name, p.description, p.ptype, p.state,
|
|
p.effect_date, p.expire_date, p.salemode, p.product_code, p.spec_note, p.product_area,
|
|
p.specific_pattern, p.reseller_orgid from (select * from (select id as offer_floor_id,
|
|
offer_orgid, bid_orgid, productid, price as floorprice, begin_date, end_date from floorprice
|
|
where bid_orgid = '%s'and del_flg = '0') as n1
|
|
LEFT JOIN (select id as floor_selling_id, productid as prdid, price as selling from floorprice where
|
|
offer_orgid = '%s' and del_flg = '0') as n2 on n1.productid = n2.prdid) as fl LEFT JOIN product as p on
|
|
fl.productid=p.id;""" % (orgid, orgid)
|
|
floorprice_res_rows = await sor.sqlExe(floor_sql, {})
|
|
floorprice_res_rows_sort = await productSort(floorprice_res_rows, flag='floorprice')
|
|
res_list.extend(discount_res_rows_sort) if discount_res_rows else ''
|
|
res_list.extend(rebate_res_rows_sort) if rebate_res_list else ''
|
|
res_list.extend(floorprice_res_rows_sort) if floorprice_res_rows else ''
|
|
return {
|
|
'status': True,
|
|
'msg': 'product search success',
|
|
'data': res_list
|
|
}
|
|
else:
|
|
ns['del_flg'] = '0'
|
|
ns['sort'] = 'create_at'
|
|
ns['order'] = 'desc'
|
|
ns['page'] = ns.get('page', 1)
|
|
prd_result = await sor.R('product',ns)
|
|
return {
|
|
"status": True,
|
|
"msg": "product search success",
|
|
"data": prd_result
|
|
}
|
|
except Exception as e:
|
|
raise e
|
|
return {
|
|
"status": False,
|
|
"msg": "product search failed",
|
|
"data":""
|
|
}
|
|
|
|
|
|
ret = await productSearch(params_kw)
|
|
return ret |