def get_finance_car_series_county_info(city_id=None, car_series_id=None):
"""
根据城市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)
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
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.id in ({{dealer_id_list}})
AND 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
GROUP BY
a.county_id
ORDER 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)
county_list = dictfetchall(cursor)
if not county_list:
return None
result_dict = {
'county_list': county_list,
}
county_count = 0
for county in county_list:
county_count += county['dealer_count']
result_dict['county_count'] = county_count
return result_dict
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_dealer_id_list_by_car(car_brand_id=None,
car_series_id=None):
"""
根据县区ID查找
"""
car_brand_id = common_utils.to_int(car_brand_id)
car_series_id = common_utils.to_int(car_series_id)
dealer_sql_template = '''
SELECT
id
FROM
t_base_dealer
WHERE
is_enable=1
AND is_frozen=0
{% if car_series_id %}
AND car_series_ids like '%,{{car_series_id}},%'
{% elif car_brand_id %}
AND cbb_car_brand_code like '%,{{car_brand_id}},%'
{% endif %}
'''
param = {
'car_brand_id': car_brand_id,
'car_series_id': car_series_id,
}
dealer_sql = Template(dealer_sql_template).render(param)
cursor = connection().cursor()
cursor.execute(dealer_sql)
dealer_list = dictfetchall(cursor)
if not dealer_list:
return None
dealer_id_list = []
for tmp_dealer in dealer_list:
dealer_id_list.append(tmp_dealer['id'])
return dealer_id_list
def get_dealer_city_activity(city_id=None, activity_type=1, count=6):
"""
通过城市ID和活动类型返回同城经销商活动
参数
----
city_id : int
城市ID
activity_type : {1, 2}
1促销活动，2店头活动
count : int
获取活动的数量
返回值
------
result_list : list
返回排好序的活动数组
"""
city_id = common_utils.to_int(city_id)
activity_type = common_utils.to_int(activity_type)
count = common_utils.max_int(count)
activity_ids = list_objs(model=ModelName.T_BASE_MEDIA_ACTIVITY,
is_enable=1,
orderby=['-created_date'],
count=count,
activity_type=activity_type,
city_id=city_id)
activity_ids = activity_ids.values_list('id', flat=True)
activity_list = []
for activity_id in activity_ids:
tmp_activity = activity_utils.get_activity_by_id(
activity_id=activity_id)
activity_list.append(tmp_activity)
return activity_list
def get_finance_car_series_list(dealer_id=None):
"""
通过经销商ID获取经销商当前在售车系
参数
----
dealer_id : int
经销商ID
返回值
------
result_list : list
返回在售车系数组
"""
dealer_id = common_utils.to_int(dealer_id)
dealer = dealer_utils.get_dealer_by_id(dealer_id=dealer_id)
car_series_id_list = dealer['car_series_ids']
if not car_series_id_list:
return None
result_list = []
for car_series_id in car_series_id_list:
car_series = car_series_utils.get_carseries_by_id(
car_series_id=car_series_id)
if not car_series:
continue
result_list.append(car_series)
if result_list:
result_list = sorted(
result_list,
key=lambda tmp_car_series:
(common_utils.to_int(tmp_car_series['start_guideprice']), ))
return result_list
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_finance_county_brand_dealer(county_id=None,
car_brand_id=None,
per_page=10,
page=1):
"""
根据县区ID和品牌ID返回经销商信息
先按VIP排序再按评分排序
参数
----
county_id : int
县区ID
car_brand_id : int
品牌ID
per_page : int
当前页返回的数据数量
page : int
页码
返回值
------
result_list : list
返回经销商数组
"""
(offset, count) = common_utils.offset_count(per_page=per_page, page=page)
county_id = common_utils.to_int(county_id)
car_brand_id = common_utils.to_int(car_brand_id)
dealer_id_list = dealer_utils.get_dealer_id_list(county_id=county_id,
car_brand_id=car_brand_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
%(offset)s, %(count)s
'''
param = {
'dealer_id_list': common_utils.int_list_to_str(dealer_id_list),
'offset': offset,
'count': count,
}
dealer_sql = Template(dealer_sql_template).render(param)
cursor = connection().cursor()
cursor.execute(dealer_sql, param)
dealers = dictfetchall(cursor)
result_list = []
for dealer in dealers:
dealer = dealer_utils.get_dealer_by_id(dealer_id=dealer['id'])
result_list.append(dealer)
return result_list
def get_offerprice(city_id=None,
dealer_id=None,
dealer_id_list=None,
car_series_id=None,
car_type_id=None):
"""
根据城市ID或者经销商ID或者车系ID或者车型ID返回最低报价，
车系ID和车型ID必选一个
参数
----
city_id : int, 可选
城市ID
dealer_id : int, 可选
经销商ID
dealer_id_list : list, 可选
经销商ID数组
car_series_id : int, 可选
车系ID
car_type_id : int, 可选
车型ID
返回值
------
result_dict : dict
返回最低报价
"""
city_id = common_utils.to_int(city_id)
dealer_id = common_utils.to_int(dealer_id)
dealer_id_list = str2array(dealer_id_list)
car_series_id = common_utils.to_int(car_series_id)
car_type_id = common_utils.to_int(car_type_id)
if car_type_id:
if dealer_id:
return get_offerprice_by_type_dealer(car_type_id=car_type_id,
dealer_id=dealer_id)
elif dealer_id_list:
return get_offerprice_by_type_dealer_list(
car_type_id=car_type_id, dealer_id_list=dealer_id_list)
elif city_id:
return get_offerprice_by_type_city(car_type_id=car_type_id,
city_id=city_id)
else:
return get_offerprice_by_type(car_type_id=car_type_id)
elif car_series_id:
if dealer_id:
return get_offerprice_by_series_dealer(car_series_id=car_series_id,
dealer_id=dealer_id)
elif dealer_id_list:
return get_offerprice_by_series_dealer_list(
car_series_id=car_series_id, dealer_id_list=dealer_id_list)
elif city_id:
return get_offerprice_by_series_city(car_series_id=car_series_id,
city_id=city_id)
else:
return get_offerprice_by_series(car_series_id=car_series_id)
else:
return get_offerprice_none()
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_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_offerprice_by_type_dealer(car_type_id=None, dealer_id=None):
car_type_id = common_utils.to_int(car_type_id)
dealer_id = common_utils.to_int(dealer_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,
dealer_id=dealer_id)[0]
except IndexError:
return get_offerprice_none_type(car_type_id=car_type_id)
offer_price_dict = get_offerprice_by_model(offer_price=offer_price)
return offer_price_dict
def get_activity_list_by_dealer(dealer_id=None, activity_type=2):
dealer_id = common_utils.to_int(dealer_id)
activity_type = common_utils.to_int(activity_type)
activity_ids = list_objs(model=ModelName.T_BASE_MEDIA_ACTIVITY,
is_enable=1,
orderby=['-created_date'],
count=MAX_ACTIVITY_COUNT,
activity_type=activity_type,
dealer_id=dealer_id)
activity_ids = activity_ids.values_list('id', flat=True)
activity_list = []
for activity_id in activity_ids:
tmp_activity = get_activity_by_id(activity_id=activity_id)
activity_list.append(tmp_activity)
return activity_list
def get_dealer_id_list_by_multy_city(city_id=None,
car_brand_id=None,
car_series_id=None):
"""
查找 sale_city_ids 为多个城市 '4,123,456,'
"""
city_id = common_utils.to_int(city_id)
car_brand_id = common_utils.to_int(car_brand_id)
car_series_id = common_utils.to_int(car_series_id)
dealer_sql_template = '''
SELECT
id
FROM
t_base_dealer
WHERE
is_enable=1
AND is_frozen=0
{% if city_id %}
AND sale_city_ids like '4%,{{city_id}},%'
{% endif %}
{% if car_series_id %}
AND car_series_ids like '%,{{car_series_id}},%'
{% elif car_brand_id %}
AND cbb_car_brand_code like '%,{{car_brand_id}},%'
{% endif %}
'''
param = {
'city_id': city_id,
'car_brand_id': car_brand_id,
'car_series_id': car_series_id,
}
dealer_sql = Template(dealer_sql_template).render(param)
cursor = connection().cursor()
cursor.execute(dealer_sql)
dealer_list = dictfetchall(cursor)
if not dealer_list:
# 查找 sale_city_ids 售全省 '2,123'
city_info = place_utils.get_city_by_id(city_id=city_id)
if not city_info:
return None
province_id = city_info['province_id']
return get_dealer_id_list_by_sale_province(province_id=province_id,
car_brand_id=car_brand_id,
car_series_id=car_series_id)
dealer_id_list = []
for tmp_dealer in dealer_list:
dealer_id_list.append(tmp_dealer['id'])
return dealer_id_list
def get_cartype_tax_insurance(car_type_id=0):
# 获取排量
displacement = 1600
sql = """
SELECT property_value
FROM e4sdb_data.t_base_car_type_property
where property_id in
(SELECT id FROM e4sdb_data.t_base_car_type_property_template
where property_key in ('pailiang_cc'))
and car_type_id = %(car_type_id)s;
"""
params = {}
params['car_type_id'] = car_type_id
item = db.fetchone(sql, params)
if item and item['property_value']:
displacement = to_int(item['property_value'])
rtn = {'travel_tax': 0, 'travel_insurance': 950, 'busi_insurance': 2065}
if displacement in range(1, 1001):
rtn['travel_tax'] = 180
elif displacement in range(1001, 1601):
rtn['travel_tax'] = 360
elif displacement in range(1601, 2001):
rtn['travel_tax'] = 420
elif displacement in range(2001, 2501):
rtn['travel_tax'] = 720
elif displacement in range(3001, 4001):
rtn['travel_tax'] = 3000
elif displacement > 4000:
rtn['travel_tax'] = 4500
return rtn
def get_dealer_promotion_activity(dealer_id=None, count=5):
"""
通过经销商ID获取经销商促销活动，按创建时间排序
参数
----
dealer_id : int
经销商ID
count : int
获取促销活动的数量
返回值
------
result_list : list
返回排好序的促销活动数组
"""
dealer_id = common_utils.to_int(dealer_id)
count = common_utils.max_int(count)
activity_ids = list_objs(model=ModelName.T_BASE_MEDIA_ACTIVITY,
is_enable=1,
orderby=['-created_date'],
count=count,
activity_type=1,
dealer_id=dealer_id)
activity_ids = activity_ids.values_list('id', flat=True)
activity_list = []
for activity_id in activity_ids:
tmp_activity = activity_utils.get_activity_by_id(
activity_id=activity_id)
activity_list.append(tmp_activity)
return activity_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_activity_list_by_city_series(city_id=None, car_series_id=None):
city_id = common_utils.to_int(city_id)
car_series_id = common_utils.to_int(car_series_id)
activity_ids = list_objs(model=ModelName.T_BASE_MEDIA_ACTIVITY,
is_enable=1,
orderby=['-created_date'],
count=MAX_ACTIVITY_COUNT,
activity_type=1,
city_id=city_id,
car_series_id=car_series_id)
activity_ids = activity_ids.values_list('id', flat=True)
activity_list = []
for activity_id in activity_ids:
tmp_activity = get_activity_by_id(activity_id=activity_id)
activity_list.append(tmp_activity)
return activity_list
def get_finance_all_city(province_id=None):
"""
通过省ID获取城市的数据
参数
----
province_id : int
省ID
返回值
------
result_list : list
所有城市的数据的数组
"""
province_id = common_utils.to_int(province_id)
city_list = list_objs(model=ModelName.T_BASE_CITY,
is_enable=1,
is_show=1,
province_id=province_id)
if not city_list:
return None
result_list = []
for city in city_list:
city_info = place_utils.get_city_by_id(city_id=city.city_id)
if city_info:
result_list.append(city_info)
return result_list
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_cartype_id_list_by_series(car_series_id=None):
"""
根据车系ID返回对应的所有车型的ID数组
"""
car_series_id = common_utils.to_int(car_series_id)
car_type_sql = '''
SELECT
id
FROM
t_base_car_type
WHERE
is_enable=1
AND is_show=1
AND car_series_id=%(car_series_id)s
'''
param = {
'car_series_id': car_series_id,
}
cursor = connection().cursor()
cursor.execute(car_type_sql, param)
car_type_list = dictfetchall(cursor)
if not car_type_list:
return None
car_type_id_list = []
for tmp_car_type in car_type_list:
car_type_id_list.append(tmp_car_type['id'])
return car_type_id_list
def get_finance_all_county(city_id=None):
"""
通过城市ID获取县区的数据
参数
----
city_id : int
城市ID
返回值
------
result_list : list
所有县区的数据的数组
"""
city_id = common_utils.to_int(city_id)
county_list = list_objs(model=ModelName.T_BASE_COUNTY,
is_enable=1,
is_show=1,
city_id=city_id)
if not county_list:
return None
result_list = []
for county in county_list:
county_info = place_utils.get_county_by_id(county_id=county.county_id)
if county_info:
result_list.append(county_info)
return result_list
def get_dealer_on_sale_car_types_count(dealer_id=None):
"""
找好店 PC端店铺页|WAP端商家详情页
经销商在售车型总数
参数
----
dealer_id : int
经销商ID
返回值
------
count : int
返回经销商在售车型总数
"""
dealer_id = common_utils.to_int(dealer_id)
dealer = dealer_utils.get_dealer_by_id(dealer_id)
if not dealer:
return None
sale_series_id_list = dealer['car_series_ids']
car_type_count = 0
for car_series_id in sale_series_id_list:
car_type_id_list = car_type_utils.get_cartype_id_list_by_series(
car_series_id=car_series_id)
if car_type_id_list:
car_type_count += len(car_type_id_list)
return car_type_count
def get_car_series_property(car_series_id=None, prop_keys=None):
"""
车系页面，PC和WAP通用
获取车系下所有车型的多个属性
参数
----
car_series_id : int
车系ID
prop_keys : list of str
属性对应的字符串数组，例如['pailiang', 'chang']
返回值
------
result_dict : dict
每个属性的KEY对应的是一个数组，
对应的是所有车型的不同的值
"""
if not prop_keys:
return None
car_series_id = common_utils.to_int(car_series_id)
prop_keys = str2array(prop_keys)
cursor = connection().cursor()
car_series_sql = """
SELECT
a.order_no, a.property_key, a.name, b.property_value
FROM
t_base_car_type_property_template AS a,
t_base_car_type_property AS b,
t_base_car_type AS c
WHERE
a.id=b.property_id
AND b.car_type_id=c.id
AND c.car_series_id=%s
AND a.property_key in %s
AND a.is_enable=1
AND b.is_enable=1
AND c.is_enable=1
AND c.is_show=1
"""
cursor.execute(car_series_sql, [car_series_id, prop_keys])
rows = dictfetchall(cursor)
prop_dict = {}
for row in rows:
key = row['property_key']
if key not in prop_dict:
prop_dict[key] = []
prop_dict[key].append(row)
else:
is_contained = False
for prop in prop_dict[key]:
if prop['property_value'] == row['property_value']:
is_contained = True
break
if not is_contained:
prop_dict[key].append(row)
return prop_dict
def get_car_series_data(city_id=None, car_series_id=None):
"""
车系页面，PC和WAP通用。
根据城市ID，车系ID获取车系对应的基本数据，活动，报价
参数
----
city_id : int
城市ID
car_series_id : int
车系ID
返回值
------
result_dict : dict
报价是当前城市的最低经销商报价，
如果当前城市ID和车系ID没有经销商报价，
price用车系的厂家最低价start_guideprice代替
"""
city_id = common_utils.to_int(city_id)
car_series_id = common_utils.to_int(car_series_id)
car_series = car_series_utils.get_carseries_by_id(
car_series_id=car_series_id)
if not car_series:
return None
car_brand = car_brand_utils.get_carbrand_by_id(car_series['car_brand_id'])
if not car_brand:
return None
activity_list = activity_utils.get_activity_list_by_city_series(
city_id=city_id, car_series_id=car_series_id)
for activity in activity_list:
activity['dealer'] = dealer_utils.get_dealer_by_id(
dealer_id=activity['dealer_id'])
result_dict = {
'brand': car_brand,
'series': car_series,
'activity_list': activity_list,
}
offer_price = offer_price_utils.get_offerprice(
city_id=city_id,
car_series_id=car_series_id,
)
result_dict['series']['offer_price'] = offer_price
return result_dict
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_dealer_offical_car_info(dealer_id=None):
"""
找好店 PC端店铺页|WAP端商家详情页,
根据经销商ID查询在售车系信息，以官网车型级别分类
参数
----
dealer_id : int
经销商ID
返回值
------
result_dict : dict
返回当前经销商的在售车系，以官网车型级别分类，
1是三厢车，2是两厢车，3是SUV，4是原装进口
"""
dealer_id = common_utils.to_int(dealer_id)
dealer = dealer_utils.get_dealer_by_id(dealer_id)
if not dealer:
return None
sale_series_id_list = dealer['car_series_ids']
official_car_level_group_info = get_object(
model=ModelName.T_BASE_DATA_DICT_GROUP,
is_enable=1,
is_show=1,
dictgroup_name='officialCarLevel')
if not official_car_level_group_info:
return None
official_car_level_list = list_objs(
model=ModelName.T_BASE_DATA_DICT,
orderby=['sort_order'],
is_enable=1,
is_show=1,
dictgroup_id=official_car_level_group_info.id)
if not official_car_level_list:
return None
result_dict = {}
official_info_list = []
for official_cl in official_car_level_list:
car_series_list = list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['order_no'],
is_enable=1,
is_show=1,
id__in=sale_series_id_list,
official_car_level=official_cl.dict_key)
if not car_series_list:
continue
tmp_info_dict = {
'official_level_id': official_cl.dict_key,
'official_level_name': official_cl.dict_value,
'official_level_sort_order': official_cl.sort_order,
'car_series_count': car_series_list.count(),
}
official_info_list.append(tmp_info_dict)
result_dict['official_info_list'] = official_info_list
result_dict['official_info_count'] = len(official_info_list)
return result_dict
def get_car_type_all_property_back(car_type_id=None):
"""
车型页面，PC和WAP通用
获取车型所有属性
参数
----
car_type_id : int
车型ID
返回值
------
result_list : list
返回车型所有属性数组
"""
car_type_id = common_utils.to_int(car_type_id)
cursor = connection().cursor()
cursor.execute("""
SELECT
id, property_key, name, order_no
FROM
t_base_car_type_property_template
WHERE
parent_id=0
AND is_enable=1
ORDER BY
order_no, id
""")
templates = dictfetchall(cursor)
if not templates:
return None
property_list = []
for template in templates:
cursor.execute(
"""
SELECT
a.order_no, a.property_key, a.name, b.property_value
FROM
t_base_car_type_property_template AS a,
t_base_car_type_property AS b
WHERE
a.parent_id=%s
AND a.id=b.property_id
AND b.car_type_id=%s
AND a.is_enable=1
AND b.is_enable=1
ORDER BY
a.order_no, a.id
""", [template['id'], car_type_id])
propertys = dictfetchall(cursor)
if not propertys:
continue
prop_dict = {
'group_name': template['name'],
'property_list': propertys
}
property_list.append(prop_dict)
return property_list
def get_activity_by_id(activity_id=None):
"""
根据活动ID返回活动实例
"""
activity_id = common_utils.to_int(activity_id)
tmp_activity = get_object(model=ModelName.T_BASE_MEDIA_ACTIVITY,
is_enable=1,
id=activity_id)
if not tmp_activity:
return None
activity_dict = {
'id':
tmp_activity.id,
'url':
activity_url(tmp_activity.activity_type, tmp_activity.created_date,
tmp_activity.id),
'activity_title':
tmp_activity.activity_title,
'page_url':
tmp_activity.page_url,
'activity_content':
tmp_activity.activity_content,
'activity_begin_date':
tmp_activity.activity_begin_date,
'activity_end_date':
tmp_activity.activity_end_date,
'activity_type':
tmp_activity.activity_type,
'activity_type_name':
activity_type_name(tmp_activity.activity_type),
'dealer_id':
tmp_activity.dealer_id,
'car_type_id':
tmp_activity.car_type_id,
'car_series_id':
tmp_activity.car_series_id,
'car_brand_id':
tmp_activity.car_brand_id,
'city_id':
tmp_activity.city_id,
'county_id':
tmp_activity.county_id,
'created_date':
tmp_activity.created_date,
'updated_date':
tmp_activity.updated_date,
}
activity_dict['series'] = {}
if tmp_activity.car_series_id:
tmp_car_series = car_series_utils.get_carseries_by_id(
car_series_id=tmp_activity.car_series_id)
if tmp_car_series:
activity_dict['series'] = tmp_car_series
return activity_dict
def get_dealer_id_list(province_id=None, city_id=None, county_id=None,
car_brand_id=None, car_series_id=None):
"""
根据省ID或者城市ID或者县区ID或者品牌ID或者车系ID返回经销商ID数组
参数
----
province_id : int, 可选
省ID
city_id : int, 可选
城市ID
county_id : int, 可选
县区ID
car_brand_id : int, 可选
品牌ID
car_series_id : int, 可选
车系ID
返回值
------
result_list : list
经销商ID数组
"""
province_id = common_utils.to_int(province_id)
city_id = common_utils.to_int(city_id)
county_id = common_utils.to_int(county_id)
car_brand_id = common_utils.to_int(car_brand_id)
car_series_id = common_utils.to_int(car_series_id)
if county_id:
return get_dealer_id_list_by_county(county_id=county_id,
car_brand_id=car_brand_id,
car_series_id=car_series_id)
elif city_id:
return get_dealer_id_list_by_city(city_id=city_id,
car_brand_id=car_brand_id,
car_series_id=car_series_id)
elif province_id:
return get_dealer_id_list_by_province(province_id=province_id,
car_brand_id=car_brand_id,
car_series_id=car_series_id)
else:
return get_dealer_id_list_by_car(car_brand_id=car_brand_id,
car_series_id=car_series_id)
def get_dealer_id_list_by_province(province_id=None,
car_brand_id=None,
car_series_id=None):
"""
根据省ID
"""
province_id = common_utils.to_int(province_id)
car_brand_id = common_utils.to_int(car_brand_id)
car_series_id = common_utils.to_int(car_series_id)
dealer_sql_template = '''
SELECT
id
FROM
t_base_dealer
WHERE
is_enable=1
AND is_frozen=0
{% if province_id %}
AND province_id={{province_id}}
{% endif %}
{% if car_series_id %}
AND car_series_ids like '%,{{car_series_id}},%'
{% elif car_brand_id %}
AND cbb_car_brand_code like '%,{{car_brand_id}},%'
{% endif %}
'''
param = {
'province_id': province_id,
'car_brand_id': car_brand_id,
'car_series_id': car_series_id,
}
dealer_sql = Template(dealer_sql_template).render(param)
cursor = connection().cursor()
cursor.execute(dealer_sql)
dealer_list = dictfetchall(cursor)
if not dealer_list:
# 查找 sale_city_ids 售全国 '1'
return get_dealer_id_list_by_nation(car_brand_id=car_brand_id,
car_series_id=car_series_id)
dealer_id_list = []
for tmp_dealer in dealer_list:
dealer_id_list.append(tmp_dealer['id'])
return dealer_id_list
