def get(self, request):
"""提供首页广告界面"""
# 查询商品频道和分类
categories = get_categories()
# 定义一个空的字典
dict = {}
# 查询出所有的广告类别
content_categories = ContentCategory.objects.all()
# 遍历所有的广告类别, 然后放入到定义的空字典中:
for cat in content_categories:
# 获取类别所对应的展示数据, 并对数据进行排序:
# key:value ==> 商品类别.key:具体的所有商品(排过序)
dict[cat.key] = cat.content_set.filter(status=True).order_by('sequence')
# 拼接参数:
context = {
# 这是首页需要的一二级分类信息:
'categories': categories,
# 这是首页需要的能展示的三级信息:
'contents': dict,
}
# 返回界面, 同时传入参数:
return render(request, 'index.html', context=context)
def get(self, request, sku_id):
"""
获取商品详情页
:param request:
:param sku_id:
:return:
"""
# 获取商品频道分类
categories = get_categories()
sku = SKU.objects.get(id=sku_id)
category = sku.category
# 获取商品sku规格
data = get_goods_and_spec(sku_id, request)
# 根据商品类别id获取商品导航页
breadcrumb = get_breadcrumb(category)
# 组合参数
context = {
'categories': categories,
'goods': data.get('goods'),
'sku': data.get('sku'),
'specs': data.get('goods_specs'),
'breadcrumb': breadcrumb,
}
# 进行返回
return render(request, 'detail.html', context=context)
def get(self, request, sku_id):
"""提供商品详情页"""
# 商品分类菜单
categories = get_categories()
try:
sku = SKU.objects.get(id=sku_id)
sku.images = sku.skuimage_set.all()
except SKU.DoesNotExist:
return render(request, '404.html')
# 面包屑导航
category = sku.category
breadcrumb = get_breadcrumb(category)
# 调用封装的函数, 根据 sku_id 获取对应的
# 1. 类别( sku )
# 2. 商品( goods )
# 3. 商品规格( spec )
data = get_goods_and_spec(sku_id, request)
# 拼接参数，生成静态 html 文件
context = {
'categories': categories,
'goods': data.get('goods'),
'specs': data.get('goods_specs'),
'sku': data.get('sku'),
'breadcrumb': breadcrumb,
}
return render(request, 'detail.html', context)
def generate_static_sku_detail_html(sku_id):
"""生成商品详情页的静态页面"""
# 生成商品分类
categories = get_categories()
sku = SKU.objects.get(id=sku_id)
# 获取导航栏的数据,面包屑
goods = sku.goods
goods.channel = goods.category1.goodschannel_set.all()[0]
# 获取商品规格的参数id(红/白,7p/13p)
sku_specs = sku.skuspecification_set.order_by('spec_id')
sku_key = []
for spec in sku_specs:
# 取到规格相应的选项的内容参数id
sku_key.append(spec.option.id)
# 获取商品(spu)的全部规格(颜色,尺寸)
skus = goods.sku_set.all()
spec_sku_map = {}
for s in skus:
s_specs = s.skuspecification_set.order_by('spec_id')
key = []
for spec in s_specs:
key.append(spec.option.id)
spec_sku_map[tuple(key)] = s.id
# {
# ([颜色,尺寸],): sku_1,
# ([],): sku_2,
# }
specs = goods.goodsspecification_set.order_by('id')
# 若当前sku的规格信息不完整，则不再继续
if len(sku_key) < len(specs):
return
for index, spec in enumerate(specs):
# 复制当前sku的规格键
key = sku_key[:]
# 该规格的选项
options = spec.specificationoption_set.all()
for option in options:
# 在规格参数sku字典中查找符合当前规格的sku
key[index] = option.id
option.sku_id = spec_sku_map.get(tuple(key))
spec.options = options
# 渲染模板，生成静态html文件
context = {
'categories': categories,
'goods': goods,
'specs': specs,
'sku': sku
}
template = loader.get_template('detail.html')
html_text = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'goods/' + str(sku_id) + '.html')
with open(file_path, 'w') as f:
f.write(html_text)
def get(self, request):
"""提供首页广告界面"""
# 查询商品频道和分类
categories = get_categories()
# 定义一个空的字典
dict = {}
# 查询出所有的广告类别
content_categories = ContentCategory.objects.all()
# 遍历所有的广告类别, 然后放入到定义的空字典中:
for cat in content_categories:
# 获取类别所对应的展示数据, 并对数据进行排序:
# key:value ==> 商品类别.key:具体的所有商品(排过序)
dict[cat.key] = cat.content_set.filter(status=True).order_by('sequence')
# 拼接参数:
context = {
# 这是首页需要的一二级分类信息:
'categories': categories,
# 这是首页需要的能展示的三级信息:
'contents': dict,
}
# 返回界面, 同时传入参数:
return render(request, 'index.html', context=context)
def generate_static_index_html():
'''
把首页生成静态页面
:return:
'''
# 商品分类数据:
categories = get_categories()
# 1.广告内容
# 2.获取所有的广告类别
content_categories = ContentCategory.objects.all()
dict = {}
# 3.遍历所有的广告类别, 获取每一个
for cat in content_categories:
# 4.定义一个字典, 把广告类别对应的内容放到字典中
dict[cat.key] = cat.content_set.filter(
status=True).order_by('sequence')
# 5.拼接参数
context = {'categories': categories, 'contents': dict}
# 6.返回
# return render(request, 'index.html', context)
# 获取首页模板文件
template = loader.get_template('index.html')
# 渲染首页html字符串
html_text = template.render(context)
# 将首页html字符串写入到指定目录，命名'index.html'
file_path = os.path.join(settings.STATICFILES_DIRS[0], 'index.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def get(self, request, sku_id):
'''
根据sku_id 获取对应的商品, 整理格式, 返回
:param request:
:param sku_id:
:return:
'''
# 1.根据sku_id 获取对应的商品
data = get_goods_and_spec(sku_id, request)
# 3.获取商品分类
categories = get_categories()
breadcrumb = get_breadcrumb(data.get('goods').category3)
# 4.整理格式
context = {
'categories': categories,
'sku': data.get('sku'),
'goods': data.get('goods'),
'specs': data.get('goods_specs'),
'breadcrumb': breadcrumb
}
# 5.返回
return render(request, 'detail.html', context)
def generate_static_index_html():
"""生成静态的主页html文件"""
# 直接把静态页面的代码复制过来
# 获取商品频道及类别
categories = get_categories()
# 获取所有首页广告类别
contents = ContentCategory.objects.all()
content = dict()
# 遍历所有的广告获取所有类别对应的广告的信息(定义一个字典,存放广告类别的key对应的value是此条广告类别所有的广告的对象)
for con in contents:
content[con.key] = con.content_set.filter(
status=True).order_by('sequence')
#
context = {'categories': categories, 'contents': content}
# return render(request, 'index.html', context=context)
# 分开进行返回,写入到文件中
# 获取首页模板文件
template = loader.get_template('index.html')
# 渲染首页html字符串
html_text = template.render(context)
# 将首页html字符串写入到指定目录,命名'index.html'
file_path = os.path.join(settings.STATICFILES_DIRS[0], 'index.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def get(self, request):
'''
返回首页页面
:param request:
:return:
'''
# 商品分类数据:
categories = get_categories()
# 1.广告内容
# 2.获取所有的广告类别
content_categories = ContentCategory.objects.all()
dict = {}
# 3.遍历所有的广告类别, 获取每一个
for cat in content_categories:
# 4.定义一个字典, 把广告类别对应的内容放到字典中
dict[cat.key] = cat.content_set.filter(
status=True).order_by('sequence')
# 5.拼接参数
context = {'categories': categories, 'contents': dict}
# 6.返回
return render(request, 'index.html', context)
def generate_static_sku_detail_html(sku_id):
"""
生成静态商品详情页面
:param sku_id: 商品id值
"""
# 商品分类菜单
dict = get_categories()
goods, specs, sku = get_goods_and_spec(sku_id)
# 渲染模板，生成静态html文件
context = {
'categories': dict,
'goods': goods,
'specs': specs,
'sku': sku
}
# 加载 loader 的 get_template 函数, 获取对应的 detail 模板
template = loader.get_template('detail.html')
# 拿到模板, 将上面添加好的数据渲染进去.
html_text = template.render(context)
# 拼接模板要生成文件的位置:
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR, 'goods/' + str(sku_id) + '.html')
# 写入
with open(file_path, 'w') as f:
f.write(html_text)
def generate_static_index_html():
#==========提取类别频道数据===========
categories = get_categories()
#==========提取首页广告数据===========
#定义一个字典来存储广告内容部分
contents = {}
#从广告类别模型类中获取所有数据,存放到变量中:
content_categories = ContentCategory.objects.all()
#遍历每一个广告类别, 把对应的广告内容添加到contents字典里
for cat in content_categories:
#例如: 滚动广告里有xxx这三个广告内容
contents[cat.key]=Content.objects.filter(category=cat,status=True).order_by('sequence')
# 把类别频道数据和广告内容数据整合到一个新字典里
context = {'categories': categories, 'contents': contents}
#==========提取template模板=========
#根据导入的loader获取'index.html'模板
template = loader.get_template('index.html')
#==========生成新的静态化页面给前端====
# 将context渲染到模板中, 生成渲染过的模板
html_text = template.render(context)
#我们拼接新的index.html模板将要生成的所在地地址:
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,'index.html')
#以写的权限,将渲染过的模板重新生成,写入到文件中
with open(file_path,'w',encoding='utf-8') as f:
f.write(html_text)
def generate_static_sku_detail_html(sku_id):
# 分组频道参数
categories = get_categories()
goods, sku, specs = get_goods_and_spec(sku_id)
# =================模版渲染===================
# 构建模版参数
context = {
'categories': categories, # 用于构建详情页面商品频道
'goods': goods, # 当前sku商品的spu商品（Goods模型类）
'sku': sku,
'specs': specs # 传入的是当前sku商品从属的spu拥有的规格及其选项
}
# 获取模版
template = loader.get_template('detail.html')
# 调用模版渲染函数，得出完整的html页面
sku_html_text = template.render(context=context)
# 写入静态文件
file_path = os.path.join(
settings.GENERATED_STATIC_HTML_DIR,
'goods/' + str(sku_id) + '.html' # goods/16.html
)
with open(file_path, 'w') as f:
f.write(sku_html_text)
def generate_static_index_html():
"""
生成静态的主页html文件
"""
print('%s: generate_static_index_html' % time.ctime())
# 获取商品频道和分类
categories = get_categories()
# 广告内容
contents = {}
content_categories = ContentCategory.objects.all()
for cat in content_categories:
contents[cat.key] = cat.content_set.filter(status=True).order_by('sequence')
# 渲染模板
context = {
'categories': categories,
'contents': contents
}
# 获取首页模板文件
template = loader.get_template('index.html')
# 渲染首页html字符串
html_text = template.render(context)
# 将首页html字符串写入到指定目录，命名'index.html'
file_path = os.path.join(settings.STATICFILES_DIRS[0], 'index.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def generate_static_index_html():
categories = get_categories()
# =====================生成首页广告部分数据=======================
# 我们定义一个字典, 里面将要存储广告内容部分:
contents = {}
# 从 ContentCategory 模型类中获取所有数据, 存放到 content_categories 中:
content_categories = ContentCategory.objects.all()
# 遍历刚刚获取的所有数据: 拿到每一个广告分类 cat:
for cat in content_categories:
# 根据广告分类的 外键反向
# 获取广告内容中状态为 True 并且按 sequence 排序的部分,
# 赋值给上面定义的字典, 快捷键(cat.key) 作为 key, 排序的部分作为value
contents[cat.key] = Content.objects.filter(
category=cat, status=True).order_by('sequence')
# 第二部分: 模板渲染部分:
# 把上面两部分获取的有序字典和字典作为变量,拼接新的字典 context
context = {'categories': categories, 'contents': contents}
# =====================获取模板,把数据添加进去生成页面====================
# 根据导入的 loader 获取 'index.html' 模板
template = loader.get_template('index.html')
# 拿到模板, 然后将 context 渲染到模板中, 生成渲染过的模板
html_text = template.render(context)
# 我们拼接新的 index.html 模板将要生成的所在地地址:
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'index.html')
print(time.time())
# 以写的权限,将渲染过的模板重新生成, 写入到文件中.
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def get(self, request):
'''
提供首页页面
:param request:
:return:
'''
# 1. 获取分类的三级数据
categiries = get_categories()
# 2. 获取所有的广告分类
content_categories = ContentCategory.objects.all()
# 5. 组织数据
dict = {}
# 3. 遍历所有的广告分类, 获取每一个分类
for cat in content_categories:
# 4. 根据分类获取广告内容(展示的)
dict[cat.key] = cat.content_set.filter(
status=True).order_by('sequence')
context = {'categories': categiries, 'contents': dict}
# 6. 返回
return render(request, 'index.html', context=context)
def generate_static_sku_detail_html(sku_id):
"""
生成静态商品详情页面
:param sku_id: 商品sku id
"""
# 商品分类菜单
categories = get_categories()
# 获取当前sku的信息
sku = SKU.objects.get(id=sku_id)
cat3 = sku.category
cat2 = cat3.parent
cat1 = cat2.parent
cats = {
'cat1': cat1,
'cat2': cat2,
'cat3': cat3,
}
# 渲染模板，生成静态html文件
context = {'categories': categories, 'sku': sku, 'cats': cats}
template = loader.get_template('detail.html')
html_text = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'goods/' + str(sku_id) + '.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
print(sku_id)
def get(self, request, category_id, page_num):
"""提供商品列表页"""
# 判断category_id是否正确
try:
# 获取三级菜单分类信息
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return HttpResponseNotFound('GoodsCategory 不存在')
# 查询商品频道分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
# 接收sort参数:如果用户不传,就是默认的排序规则
sort = request.GET.get('sort','defayle')
# 按照排序规则查询该分类商品SKU信息
if sort == 'price':
sortkind = 'price'
elif sort == 'hot':
sortkind = '-sales'
else:
# 'price'和'sales'以外的所有排序方式都归为'default'
sortkind = 'create_time'
# 获取当前分类并且上架的商品(并且对商品按照排序字段进行排序)
skus = SKU.objects.filter(category=category,is_launched=True).order_by(sortkind)
# 创建分页器:每页N条记录
# 列表页每页商品数据量
# GOODS_LIST_LIMIT = 5
paginator = Paginator(skus,5)
try:
# 分页后数据
page_skus = paginator.page(page_num)
except EmptyPage:
# 如果page_num不正确,默认给用户404
return HttpResponseNotFound('empty page')
# 获取列表页总页数
total_page = paginator.num_pages
# 渲染页面
context = {
'categories':categories, # 频道分类
'breadcrumb':breadcrumb, # 面包屑导航
'sort': sort, # 排序字段
'category': category, # 第三级分类
'page_skus': page_skus, # 分页后数据
'total_page': total_page, # 总页数
'page_num': page_num, # 当前页码
}
return render(request, 'list.html',context)
def generate_static_index_html():
"""
生成静态的主页html文件
"""
print('%s: generate_static_index_html' % time.ctime())
# 商品频道及分类菜单
# 使用有序字典保存类别的顺序
# categories = {
# 1: { # 组1
# 'channels': [{'id':, 'name':, 'url':},{}, {}...],
# 'sub_cats': [{'id':, 'name':, 'sub_cats':[{},{}]}, {}, {}, ..]
# },
# 2: { # 组2
#
# }
# }
# categories = OrderedDict()
# channels = GoodsChannel.objects.order_by('group_id', 'sequence')
# for channel in channels:
# group_id = channel.group_id # 当前组
#
# if group_id not in categories:
# categories[group_id] = {'channels': [], 'sub_cats': []}
#
# cat1 = channel.category # 当前频道的类别
#
# # 追加当前频道
# categories[group_id]['channels'].append({
# 'id': cat1.id,
# 'name': cat1.name,
# 'url': channel.url
# })
# # 构建当前类别的子类别
# for cat2 in cat1.goodscategory_set.all():
# cat2.sub_cats = []
# for cat3 in cat2.goodscategory_set.all():
# cat2.sub_cats.append(cat3)
# categories[group_id]['sub_cats'].append(cat2)
categories = get_categories()
# 广告内容
contents = {}
content_categories = ContentCategory.objects.all()
for cat in content_categories:
contents[cat.key] = cat.content_set.filter(
status=True).order_by('sequence')
# 渲染模板
context = {'categories': categories, 'contents': contents}
# 获取模板文件
template = loader.get_template('index.html')
# 根据数据渲染模板，返回生成的html字符串
html_text = template.render(context)
# 将字符串输出到index.html文件
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'index.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def generate_static_sku_detail_html(sku_id):
"""
生成静态商品详情页面
:param sku_id: 商品sku id
"""
categories = get_categories()
sku = SKU.objects.get(id = sku_id)
sku.images = sku.skuimage_set.all()
goods = sku.goods
goods.channel = goods.category1.goodschannel_set.all()[0]
sku_specs = sku.skuspecification_set.order_by('spec_id')
sku_key = []
for spec in sku_specs:
sku_key.append(spec.option.id)
skus = goods.sku_set.all()
spec_sku_map = {}
for s in skus:
s_specs = s.skuspecification_set.order_by('spec_id')
key = []
for spec in s_specs:
key.append((spec.option.id))
spec_sku_map[tuple(key)] = s.id
specs = goods.goodsspecification_set.order_by('id')
if len(sku_key) < len(specs):
return
for index ,spec in enumerate(specs):
key = sku_key[:]
options = spec.specificationoption_set.all()
for option in options:
key[index] = option.id
option.sku_id = spec_sku_map.get(tuple(key))
spec.options = options
context = {
'categories':categories,
'goods':goods,
'specs':specs,
'sku':sku
}
template = loader.get_template('detail.html')
html_text = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'goods/'+str(sku_id)+'.html')
with open(file_path, 'w') as f:
f.write(html_text)
def generate_static_sku_detail_html(sku_id):
try:
sku = SKU.objects.get(id=sku_id)
except SKU.DoesNotExist:
return http.HttpResponseForbidden('sku_id不正确')
# 商品分类
categories = get_categories()
# 面包屑
breadcrumb = get_breadcrumb(sku.category)
# 构建当前商品的规格键
sku_specs = sku.specs.order_by('spec_id')
sku_key = []
for spec in sku_specs:
sku_key.append(spec.option.id)
# 获取当前商品的所有SKU
skus = sku.spu.sku_set.all()
# 构建不同规格参数（选项）的sku字典
spec_sku_map = {}
for s in skus:
# 获取sku的规格参数
s_specs = s.specs.order_by('spec_id')
# 用于形成规格参数-sku字典的键
key = []
for spec in s_specs:
key.append(spec.option.id)
# 向规格参数-sku字典添加记录
spec_sku_map[tuple(key)] = s.id
# 获取当前商品的规格信息
goods_specs = sku.spu.specs.order_by('id')
# 若当前sku的规格信息不完整，则不再继续
if len(sku_key) < len(goods_specs):
return
for index, spec in enumerate(goods_specs):
# 复制当前sku的规格键
key = sku_key[:]
# 该规格的选项
spec_options = spec.options.all()
for option in spec_options:
# 在规格参数sku字典中查找符合当前规格的sku
key[index] = option.id
option.sku_id = spec_sku_map.get(tuple(key))
spec.spec_options = spec_options
context = {
'categories': categories,
'breadcrumb': breadcrumb,
'sku': sku,
'specs': goods_specs,
}
template = loader.get_template('detail.html')
html_text = template.render(context)
file_path = os.path.join(settings.STATICFILES_DIRS[0],
'detail/' + str(sku_id) + '.html')
with open(file_path, 'w') as f:
f.write(html_text)
def generate_static_list_search_html():
"""生成静态的商品列表页面"""
#商品分类菜单
categories = get_categories()
#渲染模板，生成静态html文件
context = {'categories': categories}
template = loader.get_template('list.html')
html_text = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'list.html')
with open(file_path, 'w') as f:
f.write(html_text)
def get(self, request, category_id, page_num):
"""提供商品列表页"""
try:
# 获取三级菜单分类信息:
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('GoodsCategory 不存在')
# 查询商品频道分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
sort = request.GET.get('sort', 'default')
# 按照排序规则查询该分类商品的sku信息
if sort == 'price':
# 按照价格由低到高
sortkind = 'price'
elif sort == 'hot':
# 按照销量由高到低
sortkind = '-sales'
else:
sort = 'default'
sortkind = 'create_time'
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(sortkind)
# 创建分页器:每页N条记录
# # 列表页每页商品数据量
# GOODS_LIST_LIMIT = 5
paginator = Paginator(skus, 5)
# 获取每页商品的数据
try:
page_skus = paginator.page(page_num)
except EmptyPage:
# 如果page_num 不正确,默认给用户404
return http.HttpResponseNotFound('empty page')
# 获取列表的总页数
total_page = paginator.num_pages
# 渲染页面
context = {
'categories': categories,
'breadcrumb': breadcrumb,
'sort': sort, # 排序字段
'category': category, # 第三级分类
'page_skus': page_skus, # 分页后数据
'total_page': total_page, # 总页数
'page_num': page_num, # 当前页码
}
return render(request, 'list.html', context)
def generate_static_index_html():
"""生成主页静态文件"""
print('%s: generate_static_index_html' % time.ctime())
# 定义有序字典变量: categories
# 字典内容: 商品频道及分类菜单
# 创建有序字典
categories = get_categories()
# 广告内容
contents = {}
# contents = {
# 'index_lbt': [广告类型],
# 'index_lbt': [广告类型],
# }
content_categories = ContentCategory.objects.all()
for cat in content_categories:
contents[cat.key] = cat.content_set.filter(
status=True).order_by('sequence')
# 图书广告
advertise_categories = AdvertiseCategory.objects.all()
advertises = []
for cat in advertise_categories:
advertise = {}
advertise['cat'] = cat
advertise['skus_cats'] = []
advertise['skus'] = []
for a in Advertise.objects.filter(category=cat):
# advertise['skus'].append(a.sku)
if a.sku.category not in advertise['skus_cats']:
advertise['skus_cats'].append(a.sku.category)
for cat in advertise['skus_cats']:
advertise['skus'].append(
SKU.objects.filter(category=cat,
advertise__category=advertise['cat']))
advertises.append(advertise)
# 渲染渲染
context = {
'categories': categories,
'contents': contents,
'advertises': advertises
}
template = loader.get_template('index.html')
html_text = template.render(context)
# 主页静态文件存储路径
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'index.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def get(self, request, category_id, page_num):
"""
展示商品列表详情页
:param request:
:return:
"""
# 获取参数
sort = request.GET.get('sort', 'default')
# 校验参数
# 路由里面已经进行过正则匹配了
# if not all([category_id, page_num]):
# return http.HttpResponseForbidden('缺少必传参数')
try:
# 根据商品id获取商品列表并排序
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('GoodCategory 不存在')
# 获取商品类别
categories = get_categories()
# 根据商品类别id获取商品导航页
breadcrumb = get_breadcrumb(category)
# 根据sort的内容确定排序的方式
if sort == 'price':
sort_kind = 'price'
elif sort == 'hot':
sort_kind = '-sales'
else:
sort_kind = 'create_time'
sku_s = category.sku_set.filter(is_launched=True).order_by(sort_kind)
# 创建分页对象
paginator = Paginator(sku_s, 5)
# 根据页数返回页面的数据
try:
content = paginator.page(page_num)
except EmptyPage:
return http.HttpResponseNotFound('页面不存在')
# 返回总页数
page_nums = paginator.num_pages
# 拼接数据进行返回
context = {
'categories': categories,
'breadcrumb': breadcrumb,
'sort': sort,
'category': category,
'page_skus': sku_s,
'total_page': page_nums,
'page_num': page_num
}
return render(request, 'list.html', context=context)
def get(self, request, category_id, page_num):
"""提供商品列表页"""
# 1.校验category_id
try:
# 获取三级菜单分类信息
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('GoodsCategory不存在')
# 2.获取商品频道分类
categories = get_categories()
# 3.获取面包屑导航
breadcrumb = get_breadcrumb(category)
# 4.获取前端用查询字符串方式传来的sort参数,如没有,则取默认值default
sort = request.GET.get('sort', 'default')
# 5.判断排序方式,确认排序依据
if sort == 'price':
# 按照价格由低到高排序
sortkind = 'price'
elif sort == 'hot':
# 按照销量由高到低排序
sortkind = '-sales'
else:
sort = 'default'
# 默认排序,按照创建时间排序
sortkind = 'create_time'
# 6.获取当前分类并且上架的商品,并对商品按照上面的排序方式进行排序
skus = SKU.objects.filter(category=category, is_launched=True).order_by(sortkind)
# 7.创建一个分页器对象,第一个参数为要展示的数据列表,第二个参数为每页的显示数量
paginator = Paginator(skus, 5)
# 8.获取对应页面的商品
try:
page_skus = paginator.page(page_num)
# 如果只有四页数据,但是前端索求第五页的数据,则报错
except EmptyPage:
return http.HttpResponseNotFound('Empty Page')
# 9.获取总页数
total_page = paginator.num_pages
# 10.拼接数据字典
context = {
'categories': categories, # 频道分类
'breadcrumb': breadcrumb, # 面包屑导航
'sort': sort, # 排序字段
'category': category, # 第三级分类
'page_skus': page_skus, # 对应页面的商品
'total_page': total_page, # 总页数
'page_num': page_num # 当前页码
}
# 11.渲染页面
return render(request, 'list.html', context)
def get(self, request, sku_id):
"""提供商品详情页"""
# 获取商品频道分类
categories = get_categories()
# 调用封装的函数,根据sku_id获取对应的商品数据字典
data = get_goods_and_spec(sku_id, request)
# 拼接字典数据
context = {
'categories': categories,
'sku': data.get('sku'),
'goods': data.get('goods'),
'specs': data.get('goods_specs'),
}
# 渲染页面
return render(request, 'detail.html', context)
def generate_static_list_search_html():
"""
生成静态的商品列表页和搜索结果页html文件
:return:
"""
# 商品分类菜单
categories = get_categories()
# 渲染模板,生成静态文件
context = {'categories': categories}
template = loader.get_template('static_list.html')
static_list_html = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'list.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(static_list_html)
def generate_static_list_search_html():
"""
生成静态的商品列表页和搜索结果页html文件
"""
# 商品分类菜单
categories = get_categories()
# 渲染模板，生成静态html文件
context = {
'categories': categories,
}
template = loader.get_template('list.html')
html_text = template.render(context)
with open(settings.LIST_FILE, 'w') as f:
f.write(html_text)
def get(self, request, sku_id):
"""提供商品详情页"""
# 1.获取当前sku的信息
try:
# 根据商品的sku_id获取对应的商品
sku = SKU.objects.get(id=sku_id)
except Exception as e:
# 如果商品不存在，返回404
return render(request, '404.html')
# 2.查询商品频道分类
categories = get_categories()
# 3.渲染页面
context = {
'categories': categories,
'sku': sku,
}
return render(request, 'detail.html', context)
def generate_static_list_search_html():
"""
生成静态的商品列表页和搜索结果页html文件
"""
# 商品分类菜单
categories = get_categories()
# 渲染模板，生成静态html文件
context = {
'categories': categories,
}
template = loader.get_template('list.html') # 加载模板
html_text = template.render(context) # 渲染模板,返回渲染好的html字符串
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'list.html')
with open(file_path, 'w', encoding='utf-8') as f:
f.write(html_text)
def generate_static_sku_detail_html(sku_id):
template = loader.get_template('detail.html')
categories = get_categories()
goods, sku, specs = get_goods_and_spec(sku_id)
context = {
'categories': categories,
'goods': goods, # 当前sku从属的spu
'specs': specs, # 规格和选项信息
'sku': sku # 当前sku商品对象
}
html_text = template.render(context)
file_path = os.path.join(settings.GENERATED_STATIC_HTML_FILES_DIR,
'goods/%s.html' % sku_id)
with open(file_path, 'w') as f:
f.write(html_text)
def get(self, request):
"""提供首页广告界面"""
# 查询首页广告界面
categories = get_categories()
# 定义一个空的字典
dict = {}
# 查询出所有的广告类别
content_categories = ContentCategory.objects.all()
# 遍历所有的广告类别，然后放入到定义的空字典中
for cat in content_categories:
# 获取类别对应的展示数据， 并对数据进行排序
dict[cat.key] = cat.content_set.filter(status=True).order_by('sequence')
# 拼接参数
context = {
# 这是首页需要的一二级分类信息
'categories': categories,
# 这是首页需要的能展示的三级信息
'contents': dict
}
return render(request, 'index.html', context=context)
