def characteristic_activity(tmp_characteristic_activity):
"""
特色活动
"""
if not tmp_characteristic_activity:
return []
dict_group = get_object(model=ModelName.T_BASE_DATA_DICT_GROUP,
is_enable=1,
is_show=1,
dictgroup_name='charactActivity')
if not dict_group:
return []
dict_group_id = dict_group.id
activity_list = tmp_characteristic_activity.split(',')
prop_list = []
for activity_key in activity_list:
if activity_key:
prop = get_object(model=ModelName.T_BASE_DATA_DICT,
is_enable=1,
is_show=1,
dictgroup_id=dict_group_id,
dict_key=activity_key)
prop_list.append(prop.dict_value)
else:
prop_list.append(None)
return prop_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_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 activity_type_name(activity_type):
media_activity_type = get_object(
model=ModelName.T_BASE_MEDIA_ACTIVITY_TYPE,
is_enable=1,
activity_type=activity_type)
if not media_activity_type:
return ""
return media_activity_type.remark
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_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_catalogs(full_path):
catalogs = service.get_object(model=ModelName.T_CMS_CATALOGS,
is_enable=1,
cata_full_alias=full_path)
if catalogs:
return catalogs
else:
try:
sub_slash_index = full_path[:-1].rindex(SLASH)
except ValueError:
return None
sub_alias = full_path[:sub_slash_index]
if sub_alias in ['', '/']:
logger.warn("the root path no need to find.")
return None
catalogs = service.get_object(model=ModelName.T_CMS_CATALOGS,
is_enable=1,
cata_full_alias=sub_alias)
return catalogs if catalogs else None
def get_catalog_url(model_table=None, model_instanceid=0):
'''
根据表名与主键，查询对应的频道URL
'''
kw = get_method_dict()
if kw:
kw['is_enable'] = 1
catalog = get_object(model=ModelName.T_CMS_CATALOGS, **kw)
if not catalog:
return None
return catalog.cata_full_alias
def quality_assurance(tmp_quality_assurance):
"""
整车质保
"""
if not tmp_quality_assurance:
return ""
dict_group = get_object(model=ModelName.T_BASE_DATA_DICT_GROUP,
is_enable=1,
is_show=1,
dictgroup_name='qualityAssurance')
if not dict_group:
return ""
dict_group_id = dict_group.id
prop = get_object(model=ModelName.T_BASE_DATA_DICT,
is_enable=1,
is_show=1,
dictgroup_id=dict_group_id,
dict_key=tmp_quality_assurance)
if not prop:
return ""
return prop.dict_value
def get_sub_catalog_url(model_table=None, model_instanceid=None, sub_key=None):
'''
根据表名与主键，查询对应的频道URL
'''
kw = get_method_dict()
if kw:
kw['is_enable'] = 1
if 'sub_key' in kw:
del kw['sub_key']
catalog = get_object(model=ModelName.T_CMS_CATALOGS, **kw)
if not catalog:
return None
return catalog.cata_full_alias + '/' + str(sub_key) + '/'
def get_car_series_url(car_series_id):
'''
根据车系ID获取对应的车系的URL
'''
catalog = get_object(model=ModelName.T_CMS_CATALOGS,
is_enable=1,
as_search_result=1,
model_table=ModelName.T_BASE_CAR_SERIES.name,
model_instanceid=car_series_id)
if not catalog:
return None
result_url = catalog.cata_full_alias
return add_city_alias_url(result_url)
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 service_auth(tmp_service_auth):
"""
经销商_服务认证
"""
if not tmp_service_auth:
return []
dict_group = get_object(model=ModelName.T_BASE_DATA_DICT_GROUP,
is_enable=1, is_show=1,
dictgroup_name='serviceCertify')
if not dict_group:
return []
dict_group_id = dict_group.id
service_auth_list = tmp_service_auth.split(',')
prop_list = []
for service_auth_key in service_auth_list:
if service_auth_key:
prop = get_object(model=ModelName.T_BASE_DATA_DICT,
is_enable=1, is_show=1,
dictgroup_id=dict_group_id,
dict_key=service_auth_key)
prop_list.append(prop.dict_value)
else:
prop_list.append(None)
return prop_list
def get_county_by_id(county_id=None):
tmp_county = get_object(model=ModelName.T_BASE_COUNTY,
is_enable=1,
is_show=1,
county_id=county_id)
if not tmp_county:
return None
county_dict = {
'county_id': tmp_county.county_id,
'city_id': tmp_county.city_id,
'county_code': tmp_county.county_code,
'county_name': tmp_county.county_name,
'regionalism_code': tmp_county.regionalism_code,
'order_no': tmp_county.order_no,
'is_show': tmp_county.is_show,
}
return county_dict
def get_car_type_group_property_back(car_type_id=None,
group_key='jibencanshu'):
"""
车型页面，PC和WAP通用
获取车型一组属性
属性组别名是parent_id=0的属性
参数
----
car_type_id : int
车型ID
group_key : str
属性组对应的字符串'jibencanshu'
返回值
------
result_list : list
返回车型属性数组
"""
car_type_id = common_utils.to_int(car_type_id)
group = get_object(model=ModelName.T_BASE_CAR_TYPE_PROPERTY_TEMPLATE,
is_enable=1,
property_key=group_key)
if not group:
return None
group_id = group.id
cursor = connection().cursor()
car_type_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
WHERE
a.id=b.property_id
AND b.car_type_id=%s
AND a.parent_id=%s
AND a.is_enable=1
AND b.is_enable=1
ORDER BY
a.order_no, a.id
"""
cursor.execute(car_type_sql, [car_type_id, group_id])
rows = dictfetchall(cursor)
return rows
def get_carbrand_by_id(car_brand_id=None):
"""
根据品牌ID返回品牌实例
"""
car_brand_id = common_utils.to_int(car_brand_id)
car_brand = get_object(model=ModelName.T_BASE_CAR_BRAND,
is_enable=1,
is_show=1,
id=car_brand_id)
if not car_brand:
return None
car_brand_dict = {
'id': car_brand.id,
'name': car_brand.car_brand_cn,
'img': car_brand.logo_img,
'car_brand_en': car_brand.car_brand_en,
'car_brand_alias': car_brand.car_brand_alias,
'order_no': car_brand.order_no,
}
return car_brand_dict
def get_province_by_id(province_id=None):
tmp_province = get_object(model=ModelName.T_BASE_PROVINCE,
is_enable=1,
is_show=1,
province_id=province_id)
if not tmp_province:
return None
province_dict = {
'province_id': tmp_province.province_id,
'province_code': tmp_province.province_code,
'province_name': tmp_province.province_name,
'province_alias': tmp_province.province_alias,
'province_initial': tmp_province.province_initial,
'region_id': tmp_province.region_id,
'regionalism_code': tmp_province.regionalism_code,
'order_no': tmp_province.order_no,
'is_show': tmp_province.is_show,
}
return province_dict
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 pre_setup_context(request, catalogs):
context = init_context()
context['catalogs'] = catalogs
cata_attrs = {}
cata_attrs_list = get_cata_attrs_list(catalogs.id)
for cata_attr in cata_attrs_list:
cata_attrs[cata_attr.enname] = cata_attr
context['cata_attrs'] = cata_attrs
if catalogs.model_table != '':
_model_name = getattr(ModelName, catalogs.model_table.upper())
kwargs = {}
kwargs['model'] = _model_name
kwargs['id'] = catalogs.model_instanceid
kwargs['is_enable'] = 1
cata_model = service.get_object(**kwargs)
context['cata_model'] = cata_model
return context
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_city_by_id(city_id=None):
tmp_city = get_object(model=ModelName.T_BASE_CITY,
is_enable=1,
is_show=1,
city_id=city_id)
if not tmp_city:
return None
city_dict = {
'city_id': tmp_city.city_id,
'province_id': tmp_city.province_id,
'city_code': tmp_city.city_code,
'city_name': tmp_city.city_name,
'city_alias': tmp_city.city_alias,
'is_limited': tmp_city.is_limited,
'is_capital': tmp_city.is_capital,
'is_popular': tmp_city.is_popular,
'is_municipality': tmp_city.is_municipality,
'regionalism_code': tmp_city.regionalism_code,
'order_no': tmp_city.order_no,
'is_show': tmp_city.is_show,
}
return city_dict
def get_carseries_by_id(car_series_id=None):
"""
根据车系ID返回车系实例
"""
car_series_id = common_utils.to_int(car_series_id)
car_series = get_object(model=ModelName.T_BASE_CAR_SERIES,
is_enable=1, is_show=1, id=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
car_series_dict = {
'id': car_series.id,
'url': get_car_series_url(car_series.id),
'car_brand_id': car_series.car_brand_id,
'name': car_series.car_series_cn,
'highlight': None,
'car_property': car_property(car_series.car_property),
'introdution': car_series.brief_introdution,
'start_guideprice': car_series.start_guideprice,
'end_guideprice': car_series.end_guideprice,
'pc_thumbnail': car_series.pc_thumbnail,
'wap_thumbnail': car_series.pc_thumbnail, # car_series.wap_thumbnail,
'sales': car_series.sales,
'order_no': car_series.order_no,
'imgs': car_series_imgs(car_series.pc_thumbnail,
car_series.multi_angle_img),
# 'imgs': get_product_images(series_id=str(car_series.id),
# position=1,
# countofpage=5, pagecount=0),
'brand': car_brand,
}
return car_series_dict
def get_car_type_group_property(car_type_id=None, group_key='jibencanshu'):
"""
车型页面，PC和WAP通用
获取车型一组属性
属性组别名是parent_id=0的属性
参数
----
car_type_id : int
车型ID
group_key : str
属性组对应的字符串'jibencanshu'
返回值
------
result_list : list
返回车型属性数组
"""
car_type_id = common_utils.to_int(car_type_id)
group = get_object(model=ModelName.T_BASE_CAR_TYPE_PROPERTY_TEMPLATE,
is_enable=1,
parent_id=0,
property_key=group_key)
if not group:
return None
group_id = group.id
cursor = connection().cursor()
rows = []
get_pid_sql = '''
SELECT
id,order_no,name,property_key
FROM
t_base_car_type_property_template
WHERE
parent_id = %s
AND is_enable=1
ORDER BY
order_no,id
'''
cursor.execute(get_pid_sql, group_id)
exist_pid = dictfetchall(cursor)
id_list = []
for one_pid in exist_pid:
id_list.append(one_pid['id'])
car_type_sql = """
SELECT
property_value,property_id
FROM
t_base_car_type_property
WHERE
car_type_id=%s
AND property_id in %s
AND is_enable=1
"""
cursor.execute(car_type_sql, (car_type_id, id_list))
exist_value = dictfetchall(cursor)
tmp_dict = {}
for tmp_info in exist_value:
tmp_dict[tmp_info['property_id']] = tmp_info
tmp_list = []
for pid_son in exist_pid:
append_dict = {}
append_dict['name'] = pid_son['name']
append_dict['order_no'] = pid_son['order_no']
if pid_son['id'] in tmp_dict:
append_dict['property_value'] = tmp_dict[
pid_son['id']]['property_value']
else:
append_dict['property_value'] = ''
append_dict['property_key'] = pid_son['property_key']
tmp_list.append(append_dict)
rows = tmp_list
return rows
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_financial_pack_data(city_id=None,
car_series_id=None,
car_type_id=None,
dealer_id=None,
finacial_product_id=None,
sku_item=None,
first_pay_percent=None):
'''
根据参数，获取金融相关包装数据
'''
finance_data = get_object(model=ModelName.T_BASE_FINANCIAL_PRODUCT,
id=finacial_product_id,
is_enable=1)
finance_data = convert_obj(finance_data)
# fetch finance corp
finance_corp = get_object(model=ModelName.T_BASE_FINANCIAL_CORP,
id=finance_data['financial_corp_id'],
is_enable=1)
finance_data['corp_id'] = finance_corp.id
finance_data['corp_name'] = finance_corp.corp_name
# fetch price
kw = {}
if car_series_id: kw['car_series_id'] = car_series_id
if car_type_id: kw['car_type_id'] = car_type_id
if dealer_id: kw['dealer_id'] = dealer_id
_offer_price = offer_price_utils.get_offerprice(**kw)
offer_price = {
"public_offer_price": _offer_price['public_offer_price'],
"car_series_id": car_series_id,
"car_type_id": car_type_id,
"dealer_id": dealer_id
}
finance_data.update(offer_price)
# fetch first pay percent
first_pay_percent_obj = get_object(
model=ModelName.T_BASE_FINANCIAL_FIRST_PAY_PERCENT_REL,
finacial_product_id=finacial_product_id,
first_pay_percent=first_pay_percent,
is_enable=1)
if not first_pay_percent_obj:
return {}
first_pay_percent_obj = convert_obj(first_pay_percent_obj)
finance_data['first_pay_percent_id'] = first_pay_percent_obj['id']
finance_data['first_pay_percent'] = first_pay_percent_obj[
'first_pay_percent']
# fetch sku
financial_pro_sku_obj = get_object(
model=ModelName.T_BASE_FINANCIAL_PRO_SKU,
is_enable=1,
finacial_product_id=finacial_product_id,
sku_item=sku_item)
if not financial_pro_sku_obj:
return {}
financial_pro_sku_obj = convert_obj(financial_pro_sku_obj)
finance_data['sku_id'] = financial_pro_sku_obj['id']
finance_data['sku_name'] = financial_pro_sku_obj['sku_name']
finance_data['sku_item'] = financial_pro_sku_obj['sku_item']
finance_data['sku_rate'] = financial_pro_sku_obj['sku_rate']
rtn_data = calc_financial(**finance_data)
finance_data.update(rtn_data)
return finance_data
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_dealer_by_id(dealer_id=None):
"""
根据经销商ID返回经销商实例
"""
dealer_id = common_utils.to_int(dealer_id)
tmp_dealer = get_object(model=ModelName.T_BASE_DEALER,
is_enable=1, is_frozen=0,
id=dealer_id)
if not tmp_dealer:
return None
activity_list = activity_utils.get_activity_list_by_dealer(
dealer_id=tmp_dealer.id
)
pre_sales_score = common_utils.to_int(tmp_dealer.pre_sales_score)
after_sales_score = common_utils.to_int(tmp_dealer.after_sales_score)
sales_score = (pre_sales_score + after_sales_score) / 2
province_id = common_utils.to_int(tmp_dealer.province_id)
city_id = common_utils.to_int(tmp_dealer.city_id)
county_id = common_utils.to_int(tmp_dealer.county_id)
dealer_dict = {
'id': tmp_dealer.id,
'dlr_code': tmp_dealer.dlr_code,
'url': get_cms_sub_url(URL.DEALER, tmp_dealer.id),
'dlr_short_name': tmp_dealer.dlr_short_name,
'dlr_full_name': tmp_dealer.dlr_full_name,
'dlr_prop': tmp_dealer.dlr_prop,
'parent_dlr_id': tmp_dealer.parent_dlr_id,
'dlr_status': tmp_dealer.dlr_status,
'dlr_level': tmp_dealer.dlr_level,
'car_series_ids': car_series_ids(tmp_dealer.car_series_ids),
'sale_city_ids': tmp_dealer.sale_city_ids,
'is_sale_province': is_sale_province(tmp_dealer.sale_city_ids),
'group_id': tmp_dealer.group_id,
'email': tmp_dealer.email,
'sale_tel': tmp_dealer.sale_tel,
'service_tel': tmp_dealer.service_tel,
'service_tel_sub': tmp_dealer.service_tel_sub,
'cbb_car_brand_code': cbb_car_brand_code(tmp_dealer.cbb_car_brand_code),
'is_vip': tmp_dealer.is_vip,
'service_auth': service_auth(tmp_dealer.service_auth),
'pre_sales_score': pre_sales_score,
'after_sales_score': after_sales_score,
'sales_score': sales_score,
'pre_sales_score_prop': tmp_dealer.pre_sales_score_prop,
'after_sales_score_prop': tmp_dealer.after_sales_score_prop,
'dlr_image_url': tmp_dealer.dlr_image_url,
'province_id': province_id,
'province_name': province_name(province_id),
'city_id': city_id,
'city_name': city_name(city_id),
'county_id': county_id,
'county_name': county_name(county_id),
'cont_address': tmp_dealer.cont_address,
'zip_code': tmp_dealer.zip_code,
'longitude': common_utils.to_float(tmp_dealer.longitude),
'latitude': common_utils.to_float(tmp_dealer.latitude),
'order_no': tmp_dealer.order_no,
'dealer_activity_list': activity_list,
}
if not dealer_dict['dlr_image_url']:
dealer_dict['dlr_image_url'] = DEALER_DEFAULT_IMG_URL
return dealer_dict
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 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
