def get_car_type_price_property(city_id=None, car_type_id=None):
"""
根据城市ID和车型ID获取基本数据、报价和全部参数
参数
----
city_id : int
城市ID
car_type_id : int
车型ID
返回值
------
result_list : list
返回车型基本数据、报价和全部参数
"""
city_id = common_utils.to_int(city_id)
car_type_id = common_utils.to_int(car_type_id)
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return None
offer_price = offer_price_utils.get_offerprice(city_id=city_id,
car_type_id=car_type_id)
car_type['offer_price'] = offer_price
car_type['property'] = get_car_type_all_property(car_type_id)
return car_type
def get_offerprice_by_model(offer_price=None):
discount = common_utils.to_positive(offer_price.discount)
offer_price_dict = {
'id': offer_price.id,
'dealer_id': offer_price.dealer_id,
'car_type_id': offer_price.car_type_id,
'car_series_id': offer_price.car_series_id,
'car_brand_id': offer_price.car_brand_id,
'public_offer_price': offer_price.public_offer_price,
'purchase_tax': offer_price.purchase_tax,
'comercial_insurance': offer_price.comercial_insurance,
'compulsory_insurance': offer_price.compulsory_insurance,
'insurance_off': offer_price.insurance_off,
'travel_tax': offer_price.travel_tax,
'lisence_cost': offer_price.lisence_cost,
'other_cost': offer_price.other_cost,
'province_id': common_utils.to_int(offer_price.province_id),
'city_id': common_utils.to_int(offer_price.city_id),
'county_id': common_utils.to_int(offer_price.county_id),
'discount': discount,
'price': offer_price.public_offer_price,
'guide_price': (offer_price.public_offer_price + discount),
}
if offer_price.car_type_id:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=offer_price.car_type_id)
if tmp_car_type:
offer_price_dict['guide_price'] = tmp_car_type['guide_price']
return offer_price_dict
def get_group_series_car_types(car_series_id=None, property_key=None):
"""
PC端车系页面、车型页面
WAP端车型页面
用在更换车型的列表
根据车系ID获取所有车型，然后根据property_key属性进行分组排序
参数
----
car_series_id : int
车系ID
property_key : str
车系下的车型按什么属性分组，例如'pailiang'按排量分组
返回值
------
result_list : list
返回车系下所有车型，然后根据property_key属性进行分组
"""
car_series_id = common_utils.to_int(car_series_id)
car_types = list_objs(model=ModelName.T_BASE_CAR_TYPE,
is_enable=1,
is_show=1,
car_series_id=car_series_id)
if not car_types:
return None
car_ids = list(car_types.values_list('id', flat=True))
car_type_prop = get_object(
model=ModelName.T_BASE_CAR_TYPE_PROPERTY_TEMPLATE,
is_enable=1,
property_key=property_key)
if not car_type_prop:
return None
car_props = list_objs(model=ModelName.T_BASE_CAR_TYPE_PROPERTY,
orderby=['property_value'],
is_enable=1,
property_id=car_type_prop.id,
car_type_id__in=car_ids)
if not car_props:
return None
car_type_dict = {}
for car_type in car_types:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type.id)
car_type_dict[car_type.id] = tmp_car_type
car_dict = {}
for car_prop in car_props:
key = car_prop.property_value
if key in car_dict:
car_dict[key].append(car_type_dict[car_prop.car_type_id])
else:
car_dict[key] = []
car_dict[key].append(car_type_dict[car_prop.car_type_id])
dict_keys = car_dict.keys()
sorted_dict_keys = sorted(dict_keys)
data_list = []
for key in sorted_dict_keys:
data_dict = {'value': key, 'car_type_list': car_dict[key]}
data_list.append(data_dict)
return data_list
def get_car_types_by_car_series_id(car_series_id=None):
"""
通过车系ID返回对应的车型数据
参数
----
car_series_id : int
车系ID
返回值
------
result_list : list
返回对应车系的而所有车型的基本数据
"""
car_series_id = common_utils.to_int(car_series_id)
car_types = list_objs(model=ModelName.T_BASE_CAR_TYPE,
orderby=['guide_price'],
is_enable=1,
is_show=1,
car_series_id=car_series_id)
if not car_types:
return []
result_list = []
for car_type in car_types:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type.id)
result_list.append(tmp_car_type)
return result_list
def get_finance_car_series_car_type(city_id=None,
car_series_id=None,
car_type_id=None):
"""
PC端任性贷金融产品列表页
根据城市ID和车系ID返回对应的车型，car_series_id和car_type_id最少传一个
参数
----
city_id : int
城市ID
car_series_id : int, 可选
车系ID
car_type_id : int, 可选
车型ID
返回值
------
result_list : list
返回车系的所有车型的基本数据
"""
city_id = common_utils.to_int(city_id)
car_series_id = common_utils.to_int(car_series_id)
car_type_id = common_utils.to_int(car_type_id)
if not car_series_id:
if car_type_id:
car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type_id)
car_series_id = car_type['car_series_id']
car_type_id_list = car_type_utils.get_cartype_id_list_by_series(
car_series_id=car_series_id)
if not car_type_id_list:
return None
result_list = []
for tmp_car_type_id in car_type_id_list:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=tmp_car_type_id)
if not tmp_car_type:
continue
result_list.append(tmp_car_type)
if result_list:
result_list = sorted(result_list,
key=lambda tmp_car_type_info:
(tmp_car_type_info['name']))
return result_list
def get_city_car_type_dealer_count(city_id=None, car_type_id=None):
"""
PC端车型页面
返回对应城市ID和车型ID在各个县区的经销商的数量
参数
----
city_id : int
城市ID
car_type_id : int
车型ID
返回值
------
result_list : list
返回县区的ID，名字和各个县区的经销商数量
"""
city_id = common_utils.to_int(city_id)
car_type_id = common_utils.to_int(car_type_id)
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return None
dealer_id_list = dealer_utils.get_dealer_id_list(
city_id=city_id, car_series_id=car_type['car_series_id'])
if not dealer_id_list:
return None
price_sql_template = '''
SELECT
b.county_id AS county_id, b.county_name,
count(a.id) AS dealer_count
FROM
t_base_dealer AS a,
t_base_county AS b
WHERE
a.county_id=b.county_id
AND a.is_enable=1
AND a.is_frozen=0
AND b.is_enable=1
AND b.is_show=1
AND a.id in ({{dealer_id_list}})
GROUP BY
a.county_id
'''
price_param = {
'dealer_id_list': common_utils.int_list_to_str(dealer_id_list),
}
price_sql = Template(price_sql_template).render(price_param)
cursor = connection().cursor()
cursor.execute(price_sql, price_param)
price_list = dictfetchall(cursor)
if not price_list:
return None
return price_list
def get_offerprice_none_type(car_type_id=None):
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if car_type:
offer_price_dict = {
'public_offer_price': car_type['guide_price'],
'discount': 0,
'price': car_type['guide_price'],
'guide_price': car_type['guide_price'],
}
return offer_price_dict
return get_offerprice_none()
def get_dealer_activity_series_car_types(dealer_id=None, car_series_id=None):
"""
WAP端经销商活动页面
根据经销商ID和车系ID获取所有车型和报价，还有车系的经销商最低价最高价
参数
----
dealer_id : int
经销商ID
car_series_id : int
车系ID
返回值
------
result_dict : dict
返回所有车型和报价，还有车系的经销商最低价最高价
"""
dealer_id = common_utils.to_int(dealer_id)
car_series_id = common_utils.to_int(car_series_id)
car_types = list_objs(model=ModelName.T_BASE_CAR_TYPE,
orderby=['guide_price'],
is_enable=1,
is_show=1,
car_series_id=car_series_id)
if not car_types:
return None
car_type_list = []
car_type_price_min = 99999999
car_type_price_max = 0
for car_type in car_types:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type.id)
if not tmp_car_type:
continue
tmp_offer_price = offer_price_utils.get_offerprice(
dealer_id=dealer_id, car_type_id=car_type.id)
tmp_car_type['offer_price'] = tmp_offer_price
car_type_list.append(tmp_car_type)
# car type price
if tmp_car_type['offer_price']['price'] < car_type_price_min:
car_type_price_min = tmp_car_type['offer_price']['price']
if tmp_car_type['offer_price']['price'] > car_type_price_max:
car_type_price_max = tmp_car_type['offer_price']['price']
result_dict = {
'series':
car_series_utils.get_carseries_by_id(car_series_id=car_series_id),
'car_type_list': car_type_list
}
activity_list = activity_utils.get_activity_list_by_dealer_series(
dealer_id=dealer_id, car_series_id=car_series_id)
result_dict['series']['activity_list'] = activity_list
result_dict['series']['car_type_price_min'] = car_type_price_min
result_dict['series']['car_type_price_max'] = car_type_price_max
return result_dict
def get_car_type_by_id(car_type_id=None):
"""
根据车型ID返回车型基本信息
参数
----
car_type_id : int
车型ID
返回值
------
result_dict : dict
返回车型基本信息
"""
car_type_id = common_utils.to_int(car_type_id)
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
return car_type
def get_finance_car_series_and_car_type(city_id=None, car_series_id=None):
"""
PC端任性贷金融产品列表页
根据城市ID和车系ID返回对应的车系的基本数据和所有车型基本数据
参数
----
city_id : int
城市ID
car_series_id : int
车系ID
返回值
------
result_dict : dict
返回车系的基本数据和所有车型的基本数据
"""
city_id = common_utils.to_int(city_id)
car_series_id = common_utils.to_int(car_series_id)
car_type_id_list = car_type_utils.get_cartype_id_list_by_series(
car_series_id=car_series_id)
if not car_type_id_list:
return None
car_type_list = []
for tmp_car_type_id in car_type_id_list:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=tmp_car_type_id)
if not tmp_car_type:
continue
car_type_list.append(tmp_car_type)
if car_type_list:
car_type_list = sorted(car_type_list,
key=lambda tmp_car_type_info:
(tmp_car_type_info['name']))
result_dict = {
'car_type_list': car_type_list,
'series':
car_series_utils.get_carseries_by_id(car_series_id=car_series_id)
}
return result_dict
def get_car_type_data(city_id=None, car_type_id=None):
"""
车型页面，PC和WAP通用，
根据城市ID和车型ID获取车型数据，最低报价
参数
----
city_id : int
城市ID
car_type_id : int
车型ID
返回值
------
result_dict : dict
返回车型数据，最低报价，如果没有经销商报价就用官方指导价
"""
city_id = common_utils.to_int(city_id)
car_type_id = common_utils.to_int(car_type_id)
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return None
car_series = car_series_utils.get_carseries_by_id(
car_series_id=car_type['car_series_id'])
if not car_series:
return None
car_brand = car_brand_utils.get_carbrand_by_id(
car_brand_id=car_series['car_brand_id'])
if not car_brand:
return None
result_dict = {
'brand': car_brand,
'series': car_series,
'type': car_type,
}
offer_price = offer_price_utils.get_offerprice(city_id=city_id,
car_type_id=car_type_id)
result_dict['type']['offer_price'] = offer_price
return result_dict
def get_car_type_series_price_property(city_id=None, car_type_id=None):
"""
根据车型ID获取对应车系基本数据
和对应车系下所有车型的基本数据、报价和全部参数
参数
----
city_id : int
城市ID
car_type_id : int
车型ID
返回值
------
result_list : list
对应car_type_id的车型排在car_type_list第一个
"""
city_id = common_utils.to_int(city_id)
car_type_id = common_utils.to_int(car_type_id)
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return None
car_series_id = car_type['car_series_id']
car_series = car_series_utils.get_carseries_by_id(
car_series_id=car_series_id)
if not car_series:
return None
result_dict = {'series': car_series, 'car_type_list': []}
ctpp = get_car_type_price_property(city_id, car_type_id)
result_dict['car_type_list'].append(ctpp)
car_type_info_list = list_objs(
model=ModelName.T_BASE_CAR_TYPE,
orderby=['guide_price'],
is_enable=1,
is_show=1,
car_series_id=car_series_id).exclude(id=car_type_id)
for car_type_info in car_type_info_list:
tmp_ctpp = get_car_type_price_property(city_id, car_type_info.id)
result_dict['car_type_list'].append(tmp_ctpp)
return result_dict
def get_offerprice_by_type_city(car_type_id=None, city_id=None):
car_type_id = common_utils.to_int(car_type_id)
city_id = common_utils.to_int(city_id)
try:
offer_price = list_objs(
model=ModelName.T_BASE_OFFER_PRICE,
orderby=['public_offer_price', '-created_date'],
is_enable=1,
car_type_id=car_type_id,
city_id=city_id)[0]
except IndexError:
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return get_offerprice_none()
dealer_id_list = dealer_utils.get_dealer_id_list(
city_id=city_id, car_series_id=car_type['car_series_id'])
if not dealer_id_list:
return get_offerprice_none_type(car_type_id=car_type_id)
return get_offerprice_by_type_dealer_list(
car_type_id=car_type_id, dealer_id_list=dealer_id_list)
offer_price_dict = get_offerprice_by_model(offer_price=offer_price)
return offer_price_dict
def get_offerprice_by_id(offer_price_id=None):
offer_price_id = common_utils.to_int(offer_price_id)
offer_price = get_object(model=ModelName.T_BASE_OFFER_PRICE,
is_enable=1,
id=offer_price_id)
if not offer_price:
return None
if not offer_price.dealer_id:
return None
discount = common_utils.to_positive(offer_price.discount)
offer_price_dict = {
'id': offer_price.id,
'dealer_id': offer_price.dealer_id,
# 'dealer_name': offer_price.dealer_name,
'car_type_id': offer_price.car_type_id,
'car_series_id': offer_price.car_series_id,
'car_brand_id': offer_price.car_brand_id,
'public_offer_price': offer_price.public_offer_price,
'purchase_tax': offer_price.purchase_tax,
'comercial_insurance': offer_price.comercial_insurance,
'compulsory_insurance': offer_price.compulsory_insurance,
'insurance_off': offer_price.insurance_off,
'travel_tax': offer_price.travel_tax,
'lisence_cost': offer_price.lisence_cost,
'other_cost': offer_price.other_cost,
'province_id': common_utils.to_int(offer_price.province_id),
'city_id': common_utils.to_int(offer_price.city_id),
'county_id': common_utils.to_int(offer_price.county_id),
'discount': discount,
'price': offer_price.public_offer_price,
'guide_price': (offer_price.public_offer_price + discount),
}
if offer_price.car_type_id:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=offer_price.car_type_id)
if tmp_car_type:
offer_price_dict['guide_price'] = tmp_car_type['guide_price']
return offer_price_dict
def get_car_type_dealer(city_id=None,
county_id=None,
car_type_id=None,
per_page=10,
page=1,
orderby='price',
descending=False):
"""
车型页面，PC和WAP通用
返回对应城市ID、县区ID和车型ID的经销商
参数
----
city_id : int
城市ID
county_id : int, 可选
县区ID
car_type_id : int
车型ID
per_page : int
当前页返回的数据数量
page : int
页码
orderby : {'price', 'discount'}
price按报价排序，discount按优惠排序
descending : {0, 1}
0按升序，1按降序
返回值
------
result_list : list
返回对应城市、县区和车型的经销商
"""
(offset, count) = common_utils.offset_count(per_page=per_page, page=page)
city_id = common_utils.to_int(city_id)
county_id = common_utils.to_int(county_id)
car_type_id = common_utils.to_int(car_type_id)
orderby_price = True
if orderby == 'discount':
orderby_price = False
else:
orderby_price = True
if descending:
if isinstance(descending, str) and (descending.upper() != 'TRUE'):
descending = False
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return None
car_series_id = car_type['car_series_id']
dealer_id_list = dealer_utils.get_dealer_id_list(
city_id=city_id, county_id=county_id, car_series_id=car_series_id)
if not dealer_id_list:
return None
result_list = []
for dealer_id in dealer_id_list:
tmp_dealer = dealer_utils.get_dealer_by_id(dealer_id=dealer_id)
if not tmp_dealer:
continue
offer_price = offer_price_utils.get_offerprice(car_type_id=car_type_id,
dealer_id=dealer_id)
tmp_dealer['offer_price'] = offer_price
activity_list = activity_utils.get_activity_list_by_dealer_series(
dealer_id=tmp_dealer['id'], car_series_id=car_series_id)
tmp_dealer['activity_list'] = activity_list
result_list.append(tmp_dealer)
if result_list:
result_list = offer_price_utils.sorted_offer_price_list(
offer_price_list=result_list,
orderby_price=orderby_price,
descending=descending)
result_list = result_list[offset:(offset + count)]
return result_list
def get_dealer_group_series_car_types(dealer_id=None,
car_series_id=None,
property_key=None):
"""
找好店店铺页面
找好店商家详情页
用在更换车型的列表
根据车系ID获取所有车型，然后根据property_key属性进行分组排序
参数
----
dealer_id : int
经销商ID
car_series_id : int
车系ID
property_key : str
车系下的车型按什么属性分组，例如'pailiang'按排量分组
返回值
------
result_list : list
返回经销商所有车型报价，经销商没有报价的车型用厂家指导价代替
"""
dealer_id = common_utils.to_int(dealer_id)
car_series_id = common_utils.to_int(car_series_id)
car_types = list_objs(model=ModelName.T_BASE_CAR_TYPE,
is_enable=1,
is_show=1,
car_series_id=car_series_id)
if not car_types:
return None
car_ids = list(car_types.values_list('id', flat=True))
car_type_prop = get_object(
model=ModelName.T_BASE_CAR_TYPE_PROPERTY_TEMPLATE,
is_enable=1,
property_key=property_key)
if not car_type_prop:
return None
car_props = list_objs(model=ModelName.T_BASE_CAR_TYPE_PROPERTY,
orderby=['property_value'],
is_enable=1,
property_id=car_type_prop.id,
car_type_id__in=car_ids)
if not car_props:
return None
car_type_dict = {}
for car_type in car_types:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type.id)
if not tmp_car_type:
continue
tmp_offer_price = offer_price_utils.get_offerprice(
dealer_id=dealer_id, car_type_id=car_type.id)
tmp_car_type['offer_price'] = tmp_offer_price
car_type_dict[car_type.id] = tmp_car_type
car_dict = {}
for car_prop in car_props:
key = car_prop.property_value
if key in car_dict:
car_dict[key].append(car_type_dict[car_prop.car_type_id])
else:
car_dict[key] = []
car_dict[key].append(car_type_dict[car_prop.car_type_id])
dict_keys = car_dict.keys()
sorted_dict_keys = sorted(dict_keys)
data_list = []
for key in sorted_dict_keys:
data_dict = {'value': key, 'car_type_list': car_dict[key]}
data_list.append(data_dict)
return data_list
def get_finance_car_type_dealer(city_id=None,
county_id=None,
car_type_id=None,
per_page=10,
page=1):
"""
任性贷车型页面，PC和WAP通用
根据城市ID、县区ID和车型ID返回车型的经销商和报价
排序按 堡垒店-》价格
如果当前城市没有经销商，就返回最近的售全省的经销商的报价
参数
----
city_id : int
城市ID
county_id : int, 可选
县区ID
car_type_id : int
车型ID
per_page : int
当前页返回的数据数量
page : int
页码
返回值
------
result_list : list
返回车型的经销商和报价
"""
(offset, count) = common_utils.offset_count(per_page=per_page, page=page)
city_id = common_utils.to_int(city_id)
county_id = common_utils.to_int(county_id)
car_type_id = common_utils.to_int(car_type_id)
car_type = car_type_utils.get_cartype_by_id(car_type_id=car_type_id)
if not car_type:
return None
dealer_id_list = dealer_utils.get_dealer_id_list(
city_id=city_id,
county_id=county_id,
car_series_id=car_type['car_series_id'])
if not dealer_id_list:
return None
result_list = []
for dealer_id in dealer_id_list:
tmp_dealer = dealer_utils.get_dealer_by_id(dealer_id=dealer_id)
if not tmp_dealer:
continue
tmp_offer_price = offer_price_utils.get_offerprice(
car_type_id=car_type_id, dealer_id=dealer_id)
car_type_dict = {
'dealer': tmp_dealer,
'offer_price': tmp_offer_price,
}
result_list.append(car_type_dict)
if result_list:
result_list = sorted(result_list,
key=lambda tmp_car_type:
(-tmp_car_type['dealer']['is_vip'], tmp_car_type[
'offer_price']['public_offer_price']))
result_list = result_list[offset:(offset + count)]
return result_list
def get_on_sale_car_types(city_id=None,
car_series_id=None,
per_page=10,
page=1,
orderby='price',
descending=False):
"""
车系页面，PC和WAP通用，
根据城市ID和车系ID获取在售车型，按报价或者优惠排序
返回值里的financial目前是在PC端用到
参数
----
city_id : int
城市ID
car_series_id : int
车系ID
per_page : int
当前页返回的数据数量
page : int
页码
orderby : {'price', 'discount'}
price按报价排序，discount按优惠排序
descending : {0, 1}
0按升序，1按降序
返回值
------
result_dict : dict
返回车系基本数据和车型数组
"""
city_id = common_utils.to_int(city_id)
car_series_id = common_utils.to_int(car_series_id)
(offset, count) = common_utils.offset_count(per_page=per_page, page=page)
orderby_price = True
if orderby == 'discount':
orderby_price = False
else:
orderby_price = True
if descending:
if isinstance(descending, str) and (descending.upper() != 'TRUE'):
descending = False
car_series = car_series_utils.get_carseries_by_id(
car_series_id=car_series_id)
if not car_series:
return None
car_type_id_list = car_type_utils.get_cartype_id_list_by_series(
car_series_id=car_series_id)
if not car_type_id_list:
return None
car_type_list = []
for car_type_id in car_type_id_list:
tmp_car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type_id)
if not tmp_car_type:
continue
tmp_offer_price = offer_price_utils.get_offerprice(
city_id=city_id, car_type_id=car_type_id)
tmp_car_type['offer_price'] = tmp_offer_price
if 'dealer_id' in tmp_offer_price:
tmp_dealer = dealer_utils.get_dealer_by_id(
tmp_offer_price['dealer_id'])
tmp_car_type['dealer'] = tmp_dealer
else:
tmp_car_type['dealer'] = None
financial = get_lowest_monthly_payment(
city_id=city_id,
car_series_id=car_series_id,
car_type_id=car_type_id,
price=tmp_car_type['offer_price']['price'])
tmp_car_type['financial'] = financial
car_type_list.append(tmp_car_type)
if car_type_list:
car_type_list = offer_price_utils.sorted_offer_price_list(
offer_price_list=car_type_list,
orderby_price=orderby_price,
descending=descending)
car_type_list = car_type_list[offset:(offset + count)]
result_dict = {'series': car_series, 'car_type_list': car_type_list}
return result_dict
def utils_dealer_city_series_types(city_id=None, car_series_id=None, count=2):
"""
根据城市ID和车系ID返回当前城市的经销商
排序按照 堡垒店-》评分
"""
city_id = common_utils.to_int(city_id)
car_series_id = common_utils.to_int(car_series_id)
count = common_utils.max_int(count)
dealer_id_list = dealer_utils.get_dealer_id_list(
city_id=city_id, car_series_id=car_series_id)
if not dealer_id_list:
return None
dealer_sql_template = '''
SELECT
id, (pre_sales_score+after_sales_score)/2 as sales_score
FROM
t_base_dealer
WHERE
is_enable=1
AND is_frozen=0
AND id in ({{dealer_id_list}})
ORDER BY
is_vip desc, sales_score desc
LIMIT
%(count)s
'''
param = {
'dealer_id_list': common_utils.int_list_to_str(dealer_id_list),
'count': count,
}
dealer_sql = Template(dealer_sql_template).render(param)
cursor = connection().cursor()
cursor.execute(dealer_sql, param)
dealers = dictfetchall(cursor)
dealer_list = []
for tmp_dealer in dealers:
tmp_dealer = dealer_utils.get_dealer_by_id(dealer_id=tmp_dealer['id'])
# 获取当前经销商的在售车型和报价
price_sql_template = '''
SELECT
id, car_type_id
FROM
t_base_offer_price
WHERE
dealer_id=%(dealer_id)s
AND car_series_id=%(car_series_id)s
AND is_enable = 1
ORDER BY
public_offer_price
LIMIT
%(count)s
'''
param = {
'dealer_id': tmp_dealer['id'],
'car_series_id': car_series_id,
'count': 4,
}
price_sql = Template(price_sql_template).render(param)
cursor = connection().cursor()
cursor.execute(price_sql, param)
price_list = dictfetchall(cursor)
car_type_list = []
for price in price_list:
car_type = car_type_utils.get_cartype_by_id(
car_type_id=price['car_type_id'])
if not car_type:
continue
offer_price = offer_price_utils.get_offerprice_by_id(
offer_price_id=price['id'])
if not offer_price:
continue
car_type['offer_price'] = offer_price
car_type_list.append(car_type)
tmp_dealer['car_type_list'] = car_type_list
dealer_list.append(tmp_dealer)
return dealer_list
def get_dealer_on_sale_car_types(dealer_id=None,
car_type=0,
per_page=10,
page=1):
"""
找好店 PC端店铺页|WAP端商家详情页,
根据经销商ID和官网车型级别查询在售车型
参数
----
dealer_id : int
经销商ID
car_type : {0, 1, 2, 3, 4}
官网车型级别参数，0为全部，1是三厢，2是两厢，3是SUV，4是进口
per_page : int
当前页返回的数据数量
page : int
页码
返回值
------
result_list : list
返回当前经销商的在售车系和对应的所有车型，根据车型报价排序
"""
(offset, count) = common_utils.offset_count(per_page=per_page, page=page)
dealer_id = common_utils.to_int(dealer_id)
official_car_type = common_utils.to_int(car_type)
dealer = dealer_utils.get_dealer_by_id(dealer_id)
if not dealer:
return None
sale_series_id_list = dealer['car_series_ids']
car_series_list = None
if official_car_type == 0:
car_series_list = list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['order_no'],
offset=offset,
count=count,
is_enable=1,
is_show=1,
id__in=sale_series_id_list)
else:
car_series_list = list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['order_no'],
offset=offset,
count=count,
is_enable=1,
is_show=1,
id__in=sale_series_id_list,
official_car_level=official_car_type)
result_list = []
for tmp_car_series in car_series_list:
car_type_id_list = car_type_utils.get_cartype_id_list_by_series(
car_series_id=tmp_car_series.id)
if not car_type_id_list:
continue
car_type_list = []
for car_type_id in car_type_id_list:
car_type = car_type_utils.get_cartype_by_id(
car_type_id=car_type_id)
if not car_type:
continue
car_type['offer_price'] = offer_price_utils.get_offerprice(
dealer_id=dealer_id, car_type_id=car_type_id)
car_type_list.append(car_type)
if car_type_list:
car_type_list = sorted(car_type_list,
key=lambda tmp_car_type:
(tmp_car_type['offer_price']['price']))
activity_list = activity_utils.get_activity_list_by_dealer_series(
dealer_id=dealer_id, car_series_id=tmp_car_series.id)
info_dict = {
'series':
car_series_utils.get_carseries_by_id(
car_series_id=tmp_car_series.id),
'type_list':
car_type_list,
'activity_list':
activity_list,
}
result_list.append(info_dict)
result_list = sorted(result_list,
key=lambda price:
(price['type_list'][0]['offer_price']['price']
if price['type_list'] else 0))
return result_list