def get_car_series_search():
"""
页面右上角车系搜索列表，
只显示t_cms_catalogs里的as_search_result为1的车系，最多返回10个
参数
----
None : None
无
返回值
------
result_list : list
返回车系数组，根据t_cms_catalogs里的vieworder排序
"""
car_series_catalogs = list_objs(model=ModelName.T_CMS_CATALOGS,
orderby=['vieworder'],
count=10,
is_enable=1,
as_search_result=1,
model_table='t_base_car_series')
if not car_series_catalogs:
return []
result_list = []
for csc in car_series_catalogs:
car_series = car_series_utils.get_carseries_by_id(
car_series_id=csc.model_instanceid)
if car_series:
result_list.append(car_series)
return result_list
def get_dealer_hot_car_series(count=3):
"""
热销车系，根据t_base_car_series的sales降序排序
参数
----
count : int
获取车系的数量
返回值
------
result_list : list
返回排好序的车系数组
"""
count = common_utils.max_int(count)
car_series_list = list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['-sales'],
count=count,
is_enable=1,
is_show=1)
if not car_series_list:
return None
result_list = []
for tmp_car_series in car_series_list:
car_series = car_series_utils.get_carseries_by_id(
car_series_id=tmp_car_series.id)
if not car_series:
continue
result_list.append(car_series)
return result_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_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_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_none_series(car_series_id=None):
car_series = car_series_utils.get_carseries_by_id(
car_series_id=car_series_id)
if car_series:
offer_price_dict = {
'public_offer_price': car_series['start_guideprice'],
'discount': 0,
'price': car_series['start_guideprice'],
'guide_price': car_series['start_guideprice'],
}
return offer_price_dict
return get_offerprice_none()
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_car_series_by_id(car_series_id=None):
"""
根据车系ID获取车系基本数据
参数
----
car_series_id : int
车系ID
返回值
------
result_dict : dict
车系基本数据
"""
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)
return car_series
def get_car_article_info(city_id=None, article_id=None):
"""
PC端惠挑车测评文章页.
通过文章ID和城市ID返回对应的车系，推荐经销商
参数
----
city_id : int
城市ID
article_id : int
文章ID
返回值
------
result_dict : dict
车系按照数据库的顺序排序。
经销商排序按照 堡垒店-》评分
"""
city_id = common_utils.to_int(city_id)
article_id = common_utils.to_int(article_id)
article_rela_list = list_objs(
model=ModelName.T_CMS_ARTICLE_RELA,
# is_enable=1,
type='CAR_SERIES',
article_id=article_id)
if not article_rela_list:
return None
car_series_list = []
for article_rela in article_rela_list:
car_series = car_series_utils.get_carseries_by_id(
car_series_id=article_rela.object_id)
if car_series:
car_series_list.append(car_series)
car_series_id = car_series_list[0]['id']
result_dict = {
'car_series_list':
car_series_list,
'dealer':
utils_dealer_city_series_types(city_id=city_id,
car_series_id=car_series_id)
}
return result_dict
def get_hot_car_series(city_id=None, count=5):
"""
PC端车系和车型页面,
随机获取count个车系基本数据
参数
----
city_id : int, 没用
城市ID，只是为了接口兼容留着，不用传
count : int
要随机获取的数量
返回值
------
result_list : list
返回车系数组
"""
city_id = common_utils.to_int(city_id)
series_list = list_objs(model=ModelName.T_BASE_CAR_SERIES,
is_enable=1,
is_show=1,
pc_thumbnail__isnull=False)
series_count = series_list.count()
if series_count <= 0:
return None
count = common_utils.max_int(count)
result_list = []
offset = random.randint(0, series_count)
rand_max = 2
if series_count > count:
rand_max = int((series_count - count) / count)
if rand_max < 2:
rand_max = 2
for rand_count in range(count):
offset = (offset + random.randint(1, rand_max)) % series_count
series = series_list[offset]
series_dict = car_series_utils.get_carseries_by_id(
car_series_id=series.id)
result_list.append(series_dict)
return result_list
def get_group_brand_car_series():
"""
PC端任性贷首页选择车系
返回所有车系，按品牌排序
参数
----
None : None
无
返回值
------
result_list : list
返回所有车系，按品牌排序
"""
brand_list = list_objs(model=ModelName.T_BASE_CAR_BRAND,
is_enable=1,
is_show=1)
brand_ids = brand_list.values_list('id', flat=True)
brands = list(brand_list.values())
brand_dict = {}
for brand in brands:
tmp_brand = car_brand_utils.get_carbrand_by_id(
car_brand_id=brand['id'])
brand_dict[brand['id']] = {'brand': tmp_brand, 'series_list': []}
series_list = list(
list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['car_series_cn'],
is_enable=1,
is_show=1).values())
for series in series_list:
key = series['car_brand_id']
if key in brand_dict:
tmp_series = car_series_utils.get_carseries_by_id(
car_series_id=series['id'])
brand_dict[key]['series_list'].append(tmp_series)
result_list = []
for brand_id in brand_ids:
if brand_id in brand_dict:
result_list.append(brand_dict[brand_id])
return result_list
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_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_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 article(request, id, *args, **kwargs):
'''
read article
two default data
===============
INSERT INTO `t_cms_template` (`id`,`template_name`,`template_path`,`creator`,`created_date`,`modifier`,`update_date`,`template_type`,`template_teriminal`) VALUES (1,'默认模板','wap/site/car/news.html','admin','2016-01-13 18:59:11','admin','2016-01-13 18:59:11','ARTICLE','PC');
INSERT INTO `t_cms_template` (`id`,`template_name`,`template_path`,`creator`,`created_date`,`modifier`,`update_date`,`template_type`,`template_teriminal`) VALUES (2,'默认模板','wap/site/car/news.html','admin','2016-01-21 14:17:34','admin','2016-01-21 14:17:40','ARTICLE','WAP');
===============
'''
ids = id.split('_')
article_id = ids[0]
cur_page = 1
if len(ids) == 2:
try:
cur_page = int(ids[1])
except:
raise Http404
mobile_flag = is_mobile(request.META['HTTP_USER_AGENT'])
# fetch data
article = service.get_object(model=ModelName.T_CMS_ARTICLE, id=article_id)
if not article:
raise Http404
section = service.get_object(model=ModelName.T_CMS_SECTION,
id=article.section_id)
template_id = (section.mobile_template_id
if mobile_flag else section.pc_template_id)
template = service.get_object(model=ModelName.T_CMS_TEMPLATE,
id=template_id)
article_rela = service.list_objs(model=ModelName.T_CMS_ARTICLE_RELA,
article_id=article.id,
type='CAR_SERIES',
exclude={'status': 'DEL'})
# car_series_ids = [rela.object_id for rela in article_rela]
car_series_ids = []
for tmp_rela in article_rela:
tmp_car_series_id = tmp_rela.object_id
tmp_car_series = car_series_utils.get_carseries_by_id(
car_series_id=tmp_car_series_id)
if tmp_car_series:
car_series_ids.append(tmp_car_series['id'])
content = article.trans_content
# split the page code
content_split = re.split(u'\[#([\u4E00-\u9FA5a-zA-Z0-9]*)#\]', content)
# calc max_page
max_page = 1
if len(content_split) > 1:
max_page = int((len(content_split) - 1) / 2)
if cur_page > max_page:
raise Http404
# handle content
finalContent = []
if mobile_flag:
# mobile, return all content
for i in range(max_page):
finalContent.append(content_split[i * 2])
else:
# pc, if cur_page==0, return all content
# else return the page content
if cur_page == 0:
for i in range(max_page):
finalContent.append(content_split[i * 2])
else:
finalContent.append(content_split[(cur_page - 1) * 2])
article.trans_content = "".join(finalContent)
context = init_context()
context.update({
'article': article,
'car_series_ids': car_series_ids,
'section': section,
'paginator': {
'num_pages': max_page,
'cur_page': cur_page
}
})
if mobile_flag:
return render(request, template.template_path, context)
else:
return render(request, template.template_path, context)
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 get_dealer_by_default(city_id=None,
county_id=None,
brand_id=None,
series_id=None,
per_page=10,
page=1,
newest_activity=None):
"""
PC端找好店首页
WAP端找好店首页-默认
先按VIP排序再按评分排序
参数
----
city_id : int
城市ID
county_id : int, 可选
县区ID
brand_id : int, 可选
品牌ID
series_id : int, 可选
车系ID
per_page : int
当前页返回的数据数量
page : int
页码
newest_activity : int
是否返回最新促销活动数组 activity_list，1返回，0不返回。
会覆盖车系ID对应的促销活动数组 activity_list
返回值
------
result_dict : dict
返回当前城市的经销商数量和过滤后的经销商数量和经销商数组
"""
(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)
brand_id = common_utils.to_int(brand_id)
series_id = common_utils.to_int(series_id)
newest_activity = common_utils.to_int(newest_activity)
dealer_id_list = dealer_utils.get_dealer_id_list(city_id=city_id,
county_id=county_id,
car_brand_id=brand_id,
car_series_id=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
%(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)
dealer_list = []
for dealer in dealers:
dealer = dealer_utils.get_dealer_by_id(dealer_id=dealer['id'])
if newest_activity:
tmp_activity_list = activity_utils.get_activity_list_by_dealer(
dealer_id=dealer['id'],
activity_type=1,
)
dealer['activity_list'] = tmp_activity_list
elif series_id:
activity_list = activity_utils.get_activity_list_by_dealer_series(
dealer_id=dealer['id'], car_series_id=series_id)
dealer['activity_list'] = activity_list
dealer_list.append(dealer)
filter_count = len(dealer_id_list)
# city count
city_count = dealer_utils.get_dealer_count(city_id=city_id)
result_dict = {
'city_count': city_count,
'filter_count': filter_count,
'dealer_list': dealer_list,
'page_count': int((filter_count + count - 1) / count),
}
# filter car series
if series_id:
result_dict['car_series_list'] = [
car_series_utils.get_carseries_by_id(car_series_id=series_id)
]
else:
all_dealer_list = dealer_utils.get_dealer_list_by_id_list(
dealer_id_list=dealer_id_list)
tmp_dict = {}
for tmp_dealer in all_dealer_list:
if tmp_dealer['car_series_ids']:
for tmp_car_series_id in tmp_dealer['car_series_ids']:
tmp_dict[tmp_car_series_id] = 1
tmp_car_series_id_list = tmp_dict.keys()
car_series_list = []
for tmp_car_series_id in tmp_car_series_id_list:
car_series_info = car_series_utils.get_carseries_by_id(
car_series_id=tmp_car_series_id)
if car_series_info:
if brand_id:
if car_series_info['car_brand_id'] == brand_id:
car_series_list.append(car_series_info)
else:
car_series_list.append(car_series_info)
if car_series_list:
car_series_list = sorted(
car_series_list,
key=lambda tmp_car_series: tmp_car_series['order_no'])
result_dict['car_series_list'] = car_series_list
return result_dict
def get_car_catalog_brand_data(city_id=None,
car_brand_id=None,
per_page=10,
page=1):
"""
PC端惠挑车首页.
根据品牌ID返回车系信息
参数
----
city_id : int
城市ID
car_brand_id : int
品牌ID
per_page : int
当前页要获取的数据数量
page : int
页码
返回值
------
result_list : list
根据t_base_car_series的order_no升序排序.
"""
(offset, count) = common_utils.offset_count(per_page=per_page, page=page)
city_id = common_utils.to_int(city_id)
car_brand_id = common_utils.to_int(car_brand_id)
car_series = None
if car_brand_id == 0:
car_series = list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['order_no'],
offset=offset,
count=count,
is_enable=1,
is_show=1)
else:
car_series = list_objs(model=ModelName.T_BASE_CAR_SERIES,
orderby=['order_no'],
offset=offset,
count=count,
is_enable=1,
is_show=1,
car_brand_id=car_brand_id)
if not car_series:
return None
result_list = []
for series in car_series:
car_brand = car_brand_utils.get_carbrand_by_id(
car_brand_id=series.car_brand_id)
if not car_brand:
continue
series_data = {
'brand':
car_brand,
'series':
car_series_utils.get_carseries_by_id(car_series_id=series.id),
}
series_data['series']['offer_price'] = {}
series_data['series']['activity_list'] = []
offer_price = offer_price_utils.get_offerprice(
city_id=city_id,
car_series_id=series.id,
)
if 'dealer_id' in offer_price:
series_data['series']['offer_price'] = offer_price
activity_list = activity_utils.get_activity_list_by_dealer_series(
dealer_id=offer_price['dealer_id'], car_series_id=series.id)
series_data['series']['activity_list'] = activity_list
else:
series_data['series']['offer_price'] = {
'public_offer_price':
common_utils.to_int(series.start_guideprice),
'price': common_utils.to_int(series.start_guideprice),
'discount': 0,
'guide_price': common_utils.to_int(series.start_guideprice),
}
financial = {}
financial = get_lowest_monthly_payment(
city_id=city_id,
car_series_id=series.id,
price=series_data['series']['offer_price']['price'])
series_data['series']['financial'] = financial
result_list.append(series_data)
return result_list
def get_cartype_by_id(car_type_id=None):
"""
根据车型ID返回车型实例
"""
car_type_id = common_utils.to_int(car_type_id)
car_type = get_object(model=ModelName.T_BASE_CAR_TYPE,
is_enable=1,
is_show=1,
id=car_type_id)
if not car_type:
return None
car_series = get_object(model=ModelName.T_BASE_CAR_SERIES,
is_enable=1,
is_show=1,
id=car_type.car_series_id)
if not car_series:
return None
guide_price = common_utils.to_int(car_type.guide_price)
(offer_price_start,
offer_price_end) = offer_price_section(guide_price,
car_type.offer_price_section)
car_type_dict = {
'id':
car_type.id,
'url':
get_car_type_url(car_series.id, car_type.id),
'name':
car_type.car_type_name,
'car_brand_id':
car_type.car_brand_id,
'car_series_id':
car_type.car_series_id,
'guide_price':
car_type.guide_price,
'offer_price_section':
car_type.offer_price_section,
'offer_price_start':
offer_price_start,
'offer_price_end':
offer_price_end,
'color_code':
color_code(car_type.color_code),
'incolor_code':
incolor_code(car_type.incolor_code),
'quality_assurance':
quality_assurance(car_type.quality_assurance),
'characteristic_activity':
characteristic_activity(car_type.characteristic_activity),
'product_spot':
product_spot(car_type.product_spot),
# 'price': car_type.guide_price,
# 'discount': 0,
# 'guide_price': car_type.guide_price,
# 'dealer_id': None,
# 'imgs': get_product_images(series_id=str(car_series.id),
# model_id=str(car_type.id),
# position=1,
# countofpage=5, pagecount=0),
'imgs': []
}
if not car_type_dict['imgs']:
tmp_car_series = car_series_utils.get_carseries_by_id(
car_type_dict['car_series_id'])
if tmp_car_series:
if tmp_car_series['pc_thumbnail']:
car_type_dict['imgs'] = [{
'CDNPATH':
tmp_car_series['pc_thumbnail']
}]
# tmp_car_series = get_object(model=ModelName.T_BASE_CAR_SERIES,
# is_enable=1, is_show=1,
# id=car_type_dict['car_series_id'])
# if tmp_car_series:
# if tmp_car_series.pc_thumbnail:
# car_type_dict['imgs'] = [
# {
# 'CDNPATH': tmp_car_series.pc_thumbnail
# }
# ]
return car_type_dict
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