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_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_offical_car_info():
"""
查询车系信息，以官网车型级别分类
参数
----
None : None
无
返回值
------
result_dict : dict
返回车系信息，以官网车型级别分类，1是三厢车，2是两厢车，3是SUV，4是原装进口
"""
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,
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_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_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_finance_all_province():
"""
获取所有省的数据
参数
----
None : None
空
返回值
------
result_list : list
所有省的数据的数组
"""
province_list = list_objs(model=ModelName.T_BASE_PROVINCE,
is_enable=1,
is_show=1)
if not province_list:
return None
result_list = []
for province in province_list:
province_info = place_utils.get_province_by_id(
province_id=province.province_id)
if province_info:
result_list.append(province_info)
return result_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_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_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_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_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_search_result(words=None, *args, **kwargs):
catalogs = list_objs(model=ModelName.T_CMS_CATALOGS, as_search_result=1)
if words:
catalogs = catalogs.filter((Q(cata_name__contains=words)
| Q(cata_alias__contains=words)))
catalogs = list(catalogs.values('id', 'cata_name', 'cata_full_alias'))
logger.info(catalogs)
return catalogs
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_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 _local_localcity(self, request):
_default_regionalism_code = '110000' #北京
_city = None
try:
addrs = self._locatedcity(request)
_prov_name, _city_name, _regionalism_code = addrs[1], addrs[
2], addrs[9]
# lan address
if _prov_name in (u'本机地址', u'局域网', ''):
logger.warn('this is a lan address, can not located,'
'default to beijing')
_citys = list_objs(model=ModelName.T_BASE_CITY,
count=1,
is_enable=1,
regionalism_code=_default_regionalism_code)
_city = to_dict(_citys[0])
_city['confirm'] = False
return _city
# located city fail, jump to provincial capital
if _city_name == '':
_province = get_object(model=ModelName.T_BASE_PROVINCE,
is_enable=1,
regionalism_code=_regionalism_code)
_city = get_object(model=ModelName.T_BASE_CITY,
is_enable=1,
province_id=_province.province_id,
is_capital=1)
logger.warn(
'city can not located, now auto jump to '
'provincial capital(%s)', _city.city_name)
_city = to_dict(_city)
_city['confirm'] = False
return _city
# located city successful
_city = get_object(model=ModelName.T_BASE_CITY,
regionalism_code=_regionalism_code)
if not _city:
_city = get_object(model=ModelName.T_BASE_CITY,
regionalism_code=_default_regionalism_code)
_city = to_dict(_city)
_city['confirm'] = True
return _city
except:
_city = get_object(model=ModelName.T_BASE_CITY,
regionalism_code=_regionalism_code)
_city = to_dict(_city)
_city['confirm'] = False
return _city
def get_offerprice_by_type(car_type_id=None):
car_type_id = common_utils.to_int(car_type_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)[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_car_brand_list_by_id(car_brand_id=None):
"""
根据品牌ID获取品牌基本数据，返回的是数组
参数
----
car_brand_id : int
品牌ID，0返回所有品牌基本数据数组
返回值
------
result_list : list
品牌基本数据，如果car_brand_id=0返回的是所有品牌
"""
car_brand_id = common_utils.to_int(car_brand_id)
result_list = []
if car_brand_id == 0:
car_brand_list = list_objs(model=ModelName.T_BASE_CAR_BRAND,
is_enable=1,
is_show=1)
if car_brand_list:
for tmp_car_brand in car_brand_list:
car_brand_info = car_brand_utils.get_carbrand_by_id(
car_brand_id=tmp_car_brand.id)
if car_brand_info:
result_list.append(car_brand_info)
return result_list
else:
car_brand_list = list_objs(model=ModelName.T_BASE_CAR_BRAND,
id=car_brand_id,
is_enable=1,
is_show=1)
if car_brand_list:
for tmp_car_brand in car_brand_list:
car_brand_info = car_brand_utils.get_carbrand_by_id(
car_brand_id=tmp_car_brand.id)
if car_brand_info:
result_list.append(car_brand_info)
return result_list
def process_request(self, request):
'''
1. check path, using '/' to split
2. if the first path is a citycode, return
3. if not, load the citycode by baidu-api, redirect
'''
# get the force to update cache param
if request.GET.get('__ftuc', False):
app_local_data.force_to_update_cache = True
request.GET._mutable = True
request.GET.__delitem__('__ftuc')
request.GET._mutable = False
# refresh cache to you, work for cache refresh kit
if request.GET.get('__fucku__', False):
app_local_data.refresh_cache_to_you = True
request.GET._mutable = True
request.GET.__delitem__('__fucku__')
request.GET._mutable = False
path_splits = request.path.split('/')
citys = []
if '' != path_splits[1]:
citys = list_objs(model=ModelName.T_BASE_CITY,
count=1,
city_alias=path_splits[1])
city = citys[0] if len(citys) == 1 else None
if not city:
#city = self._loadcity(request)
city = self._local_localcity(request)
else:
city = to_dict(city)
city['confirm'] = True
request.GET._mutable = True
request.GET.__setitem__('citycode', city['city_alias'])
request.GET._mutable = False
# save the city data to local thread
app_local_data.city = city
if path_splits[1] == '__debug__':
return
if path_splits[1] == city['city_alias']:
return
else:
return HttpResponseRedirect(
'/%s%s' % (city['city_alias'], request.get_full_path()))
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 incolor_code(tmp_incolor_code):
"""
内饰颜色编码
颜色类型（1-外观，2-内饰）
"""
if not tmp_incolor_code:
return []
incolor_code_list = tmp_incolor_code.split(',')
prop_list = list_objs(model=ModelName.T_BASE_CAR_COLOR,
orderby=['order_no'],
is_enable=1,
is_show=1,
color_type=2,
id__in=incolor_code_list)
prop_list = list(prop_list.values('color_name', 'rgb_value'))
return prop_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_offerprice_by_series_dealer_list(car_series_id=None,
dealer_id_list=None):
car_series_id = common_utils.to_int(car_series_id)
dealer_id_list = str2array(dealer_id_list)
if not dealer_id_list:
return get_offerprice_none_series(car_series_id=car_series_id)
try:
offer_price = list_objs(
model=ModelName.T_BASE_OFFER_PRICE,
orderby=['public_offer_price', '-created_date'],
is_enable=1,
car_series_id=car_series_id,
dealer_id__in=dealer_id_list)[0]
except IndexError:
return get_offerprice_none_series(car_series_id=car_series_id)
offer_price_dict = get_offerprice_by_model(offer_price=offer_price)
return offer_price_dict
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 car_property(tmp_car_property):
"""
车系属性（热销，推荐，钜惠，新车，购置税减半）
"""
if not tmp_car_property:
return []
dict_group = get_object(model=ModelName.T_BASE_DATA_DICT_GROUP,
is_enable=1, is_show=1,
dictgroup_name='carSeriesProperty')
if not dict_group:
return []
dict_group_id = dict_group.id
car_prop_list = tmp_car_property.split(',')
prop_list = list_objs(model=ModelName.T_BASE_DATA_DICT,
orderby=['sort_order'],
is_enable=1, is_show=1,
dictgroup_id=dict_group_id,
dict_key__in=car_prop_list)
prop_list = list(prop_list.values_list('dict_value', flat=True))
return prop_list
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_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 _loadcity(self, request):
'''
load city by baidu api
api doc: http://developer.baidu.com/map/index.php?title=webapi/ip-api
api result example:
{
address: "CN|北京|北京|None|CHINANET|1|None", #地址
content: #详细内容
{
address: "北京市", #简要地址
address_detail: #详细地址信息
{
city: "北京市", #城市
city_code: 131, #百度城市代码
district: "", #区县
province: "北京市", #省份
street: "", #街道
street_number: "" #门址
},
point: #百度经纬度坐标值
{
x: "116.39564504",
y: "39.92998578"
}
},
status: 0 #返回状态码
}
'''
_citycode = 'beijing'
_city = None
if 'HTTP_X_FORWARDED_FOR' in request.META:
ip = request.META['HTTP_X_FORWARDED_FOR'].split(',')[-1].strip()
else:
ip = request.META['REMOTE_ADDR']
logger.info(request.META)
logger.info("user ip is %s" % (ip))
res = requests.get(LOC_API % ip)
# if object isn't json, will throw ValueError: No JSON object could be decoded
# TODO handle json exception
res_content = res.json()
if (res_content is not None and res_content['status'] != 0):
logger.warn("baidu api located fail, status:%s" % (ip))
logger.warn("located default to beijing.")
_citys = list_objs(model=ModelName.T_BASE_CITY,
count=1,
city_alias=_citycode)
_city = to_dict(_citys[0])
_city['confirm'] = False
return _city
logger.info("=======Baidu Api Result=========")
logger.info(res.json())
logger.info("================================")
addrSplit = res_content['address'].split('|')
_city_name = addrSplit[2]
_city = None
if _city_name == 'None' and addrSplit[1]:
logger.warn(
"baidu api can not located city, just located "
"in province %s", addrSplit[1])
logger.warn("default to located to Capital")
_province = get_object(model=ModelName.T_BASE_PROVINCE,
province_name=addrSplit[1])
_city = get_object(model=ModelName.T_BASE_CITY,
province_id=_province.id,
is_capital=1)
_city_name = _city.city_name
_city = to_dict(_city)
_city['confirm'] = False
else:
_city = get_object(model=ModelName.T_BASE_CITY,
city_name=_city_name)
_city = to_dict(_city)
_city['confirm'] = True
logger.info("baidu api located result city:%s" % (_city_name))
return _city
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)
