def find_file(request, key, path):
obj = get_object_or_404(SecurePath, key=key)
if os.path.exists(get_download_path(obj.key)):
filename = os.path.join(CACHE_DIR, obj.key, '%s.gif' % path)
if os.path.exists(filename):
return send_raw_file(request, filename, attachment=False)
pngs = []
for f in os.listdir(get_download_path(obj.key)):
if f.endswith('.png') and f.startswith(path):
pngs.append(os.path.join(get_download_path(obj.key), f))
if len(pngs) == 1:
return send_raw_file(request, pngs[0], attachment=False)
create_cache_dir(obj.key)
command = 'convert -delay 200 -resize 500x {0} {1}'.format(
' '.join(pngs), filename)
try:
subprocess.check_call(command.split())
except:
try:
subprocess.check_call(
command.replace('_test-pic', '-pic').split())
except:
return http.HttpResponseNotFound()
return send_raw_file(request, filename, attachment=False)
return http.HttpResponseNotFound()
def get(self, request, category_id, page_num):
sort = request.GET.get('sort', 'default')
try:
category = GoodsCategory.objects.get(id=category_id)
except:
return http.HttpResponseNotFound('GoodsCategory 不存在')
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
if sort == 'price':
sortkind = 'price'
elif sort == 'hot':
sortkind = '-sales'
else:
sortkind = 'create_time'
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(sortkind)
paginator = Paginator(skus, 5)
try:
page_skus = paginator.page(page_num)
except EmptyPage:
return http.HttpResponseNotFound('not found')
total_page = paginator.num_pages
context = {
'categories': categories,
'breadcrumb': breadcrumb,
'page_skus': page_skus,
'total_page': total_page,
'page_num': page_num,
'category': category
}
return render(request, 'list.html', context=context)
def profile(request, user_id, user_name):
"""
Gathers and displays user profile data.
"""
from django_community.config import PROFILES_ENABLED, PROFILE_TEMPLATE
from django_community.profile_utils import build_profile_information
if PROFILES_ENABLED:
try:
user = User.objects.get(id=user_id)
except ObjectDoesNotExist:
return http.HttpResponseNotFound()
context = build_profile_information(user)
user = context['user']
user = django_community.models.UserProfile.objects.insert_profile_info(
user)
else:
return http.HttpResponseNotFound()
return shortcuts.render_to_response(
PROFILE_TEMPLATE,
context,
context_instance=RequestContext(request),
)
def get(self,request,order_id):
# 1获取参数，订单号，用户名等
# 2.校验参数
try:
OrderInfo.objects.get(order_id=order_id, user=request.user)
except OrderInfo.DoesNotExist:
return http.HttpResponseNotFound("订单不存在")
# 查询订单中未评价的商品
try:
uncomment_goods = OrderGoods.objects.filter(order_id=order_id, is_commented=False)
except Exception:
http.HttpResponseNotFound("订单商品信息出错")
# 3传参 ,查看goods_judge.html中需要的参数，传之
uncomment_goods_list = []
for goods in uncomment_goods:
uncomment_goods_list.append({
'sku_id': goods.sku.id,
"name ": goods.sku.name,
"price": str(goods.price),
"default_image_url": goods.sku.default_image_url.url
})
return http.JsonResponse({'skus': uncomment_goods_list})
def delete_thing_link(request, thing):
from_hash_id = models.Thing.hash(thing)
to_hash_id = models.Thing.hash(request.POST.get("fullpath"))
try:
from_thing = models.Thing.objects.get(pathid=from_hash_id)
to_thing = models.Thing.objects.get(pathid=to_hash_id)
except models.Thing.DoesNotExist:
return http.HttpResponseNotFound("Thing not found")
# get a list of the things which the user may edit
editable = get_user_editable(request)
if from_thing.id not in editable:
return http.HttpResponseForbidden("Permission denied.");
thing_tags = models.ThingTag.objects.filter(
annotation="link", thing=from_thing, targetthing=to_thing)
if not len(thing_tags):
return http.HttpResponseNotFound("ThingTag does not exist")
thing_tags.delete()
response = {
"success": True
}
return HttpResponse(json.dumps(response), content_type="application/json")
def label(request, name_value):
"""Find a name by label.
If the label matches a single name, users are redirected
to the name detail page. Otherwise, if the label
does not exist, or the specified label matches multiple Name
objects, a status code 404 is returned.
"""
if not name_value:
return http.HttpResponseNotFound()
normalized_name = normalizeSimplified(name_value)
try:
name = Name.objects.get(normalized_name=normalized_name)
return http.HttpResponseRedirect(
reverse('name:detail', args=[name.name_id]))
except Name.DoesNotExist:
return http.HttpResponseNotFound(
'No matching term found - authoritative or variant - for "{0}"'.
format(name_value))
except Name.MultipleObjectsReturned:
return http.HttpResponseNotFound(
'There are multiple Name objects with the same name: "{0}".'.
format(normalized_name))
def get(self, request, category_id, page_num):
"""
展示商品列表页
:param request:
:return:
"""
# 判断category_id是否正确
try:
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('category_id不存在')
# 接收sort参数：如果用户不传，就是默认的排序规则
sort = request.GET.get('sort', 'default')
# 查询商品频道分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
# 按照排序规则查询给分类商品sku信息
if sort == 'price':
# 按照价格由低向高
sort_field = 'price'
elif sort == 'hot':
# 按照销量由低向高
sort_field = '-sales'
else:
# 'price'和'sales'以外的所有排序方式都归为'default'
sort = 'default'
sort_field = 'create_time'
# 查询出指定类别下的所有商品
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(sort_field)
# 创建分页器对象: Paginator(要分页的所有数据, 指定每页显示多少条数据)
paginator = Paginator(skus, constants.GOODS_LIST_LIMIT)
# 获取每页商品数据
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 get(self, request, category_id, page_num):
"""
提供当前三级类别下的所有商品(SKU)列表页
:param category_id: 三级类别ID
:param page_num: 查询页码
:return:
"""
# 判断category_id是否正确
try:
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('category_id不存在')
# 接收sort参数，默认排序方式为default
sort = request.GET.get('sort', 'default')
# 查询所有商品分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
if sort == 'price':
# 按照价格由高到低
sort_field = '-price'
elif sort == 'hot':
# 按照销量由高到低
sort_field = '-sales'
else:
sort = 'default'
sort_field = '-create_time'
# 获取当前三级类别下的所有SKU，三级类别与SKU为一对多
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(sort_field)
# 创建分页器：每页N条记录
paginator = Paginator(skus, constants.GOODS_LIST_LIMIT)
# 获取列表页总页数
total_page = paginator.num_pages
try:
# 获取当前页的SKU数据
page_skus = paginator.page(page_num)
except EmptyPage:
# 如果page_num不正确，默认给用户404
return http.HttpResponseNotFound('空页面')
context = {
'categories': categories, # 所有商品类别
'breadcrumb': breadcrumb, # 面包屑导航
'category': category, # 第三级分类的商品
'total_page': total_page, # 总页数
'page_num': page_num, # 当前页码
'page_skus': page_skus, # 当前页的所有SKU数据
'sort': sort, # 排序字段
}
return render(request, 'list.html', context)
def get(self, request, category_id, page_num):
"""提供商品列表页"""
# 判断category_id是否正确
try:
# 获取三级菜单分类信息:
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('GoodsCategory 不存在')
# 查询商品频道分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
# 增加的代码部分:
# 接收sort参数：如果用户不传，就是默认的排序规则
sort = request.GET.get('sort', 'default')
# 按照排序规则查询该分类商品SKU信息
if sort == 'price':
# 按照价格由低到高
sortkind = 'price'
elif sort == 'hot':
# 按照销量由高到低
sortkind = '-sales'
else:
# 'price'和'sales'以外的所有排序方式都归为'default'
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, constants.GOODS_LIST_LIMIT)
# 获取每页商品数据
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 get(self, request, category_id, page_num):
# 判断有没有三级分类数据
try:
category = GoodsCategory.objects.get(id=category_id)
except Exception as e:
logger.error(e)
return http.HttpResponseNotFound('GoodsCategory does not exist')
# 调用商品频道分类分数
categories = get_categories()
# 调用面包屑导航
breadcrumb = get_breadcrumb(category)
# 按照排序规则查询该分类商品SKU信息
# 获取用户的查询方式
sort = request.GET.get('sort', 'default')
# 判断
if sort == 'price':
sort_field = 'price'
elif sort == 'hot':
sort_field = '-sales'
else:
sort_field = 'create_time'
# SKU信息排序
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(sort_field)
# 分页
from django.core.paginator import Paginator
# 实例化分页器 提供内容和分页的数
pagenator = Paginator(skus, constants.GOODS_LIST_LIMIT)
# 获取总页数
total_page = pagenator.num_pages
# 获取每页的数据
try:
page_skus = pagenator.page(page_num)
except Exception as e:
logger.error(e)
return http.HttpResponseNotFound('empty page')
# 渲染页面
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 log_search_systems(request, id):
content_type = 'application/json'
if not is_valid_session(request):
return http.HttpResponseForbidden(content_type=content_type)
if request.method == 'POST':
form = LogSearchSystemForm(request.POST)
system = form.save()
response = http.HttpResponse(to_json(system),
content_type=content_type,
status=201)
response['Location'] = reverse('hatohol.views.log_search_systems',
args=[system.id])
return response
elif request.method == 'PUT':
if id is None:
message = 'id is required'
return http.HttpResponseBadRequest(to_json(message),
content_type=content_type)
try:
system = LogSearchSystem.objects.get(id=id)
except LogSearchSystem.DoesNotExist:
return http.HttpResponseNotFound(content_type=content_type)
else:
record = http.QueryDict(request.body, encoding=request.encoding)
form = LogSearchSystemForm(record, instance=system)
form.save()
return http.HttpResponse(to_json(system),
content_type=content_type)
elif request.method == 'DELETE':
if id is None:
message = 'id is required'
return http.HttpResponseBadRequest(to_json(message),
content_type=content_type)
try:
system = LogSearchSystem.objects.get(id=id)
except LogSearchSystem.DoesNotExist:
return http.HttpResponseNotFound()
else:
system.delete()
return http.HttpResponse()
else:
if id:
try:
system = LogSearchSystem.objects.get(id=id)
except LogSearchSystem.DoesNotExist:
return http.HttpResponseNotFound()
response = system
else:
systems = LogSearchSystem.objects.all().order_by('id')
response = systems
return http.HttpResponse(to_json(response), content_type=content_type)
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 get(self, request, category_id, page_num):
"""
商品列表页面
:param request:
:return:
"""
# 判断category_id是否正确
try:
category = GoodsCategory.objects.get(id=category_id)
except Exception as e:
logger.error(e)
return http.HttpResponseNotFound('category_id 不存在')
# 接收sort参数, 用户不传, 就是默认排序
sort = request.GET.get('sort', 'default')
# 查询商品分类频道
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
# 按照排序规格查询分类的SKU信息
if sort == 'price':
sort_field = 'price'
elif sort == 'hot':
sort_field = '-sales'
else:
sort = 'default'
sort_field = 'create_time'
# 分页和排序查询：category查询sku,一查多,一方的模型对象.多方关联字段.all/filter
skus = category.sku_set.filter(is_launched=True).order_by(sort_field)
# 创建分页器： 每页page_num条记录
paginator = Paginator(skus, constants.GOODS_LIST_LIMIT)
try:
page_skus = paginator.page(page_num)
except EmptyPage:
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 get(self, request, category_id, page_num):
# 判断category_id是否正确
try:
category = GoodsCategory.objects.get(id=category_id)
except GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('GoodsCategory does not exist')
# 调用商品频道三级联动
categories = get_categories()
# 调用面包屑导航
breadcrumb = get_breadcrumb(category)
# 排序
# 1 接收参数
sort = request.GET.get('sort', 'default')
# 2 校验参数
if sort == 'price':
sort_filed = 'price'
elif sort == 'hot':
sort_filed = '-sales'
else:
sort_filed = 'create_time'
# 3 对商品信息进行排序
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(sort_filed)
# 分页
# 1 创建分页器对象
paginator = Paginator(skus, constants.GOODS_LIST_LIMIT)
# 2 获取每页的数据
try:
page_skus = paginator.page(page_num)
except EmptyPage:
# 如果page_num不正确，默认给用户404
return http.HttpResponseNotFound('empty page')
# 3 获取总页数
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 get(self,request,category_id,page_num):
'''提供列页'''
# 校验参数
try:
# 三级类别
category = GoodsCategory.objects.get(id=category_id)
except Exception as e:
return http.HttpResponseNotFound('GoodsCategory does not exist')
# 面包屑导航
beradcrumb = get_beradcrumb(category)
# 查询商品分类
categories = get_categories()
# 接收排序规则
sort = request.GET.get('sort', 'default')
# 按照排序规则查询该分类商品SKU信息
# 注意一定是模型字段里的
if sort == 'price':
sort_field = 'price'
elif sort == 'hot':
# 按销量降序
sort_field = '-sales'
else:
sort = 'default'
sort_field = 'create_time'
# 商品排序
skus = SKU.objects.filter(category=category, is_launched=True).order_by(sort_field)
# 商品分页，创建分页器
paginator = Paginator(skus, 5) # 把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,
'beradcrumb' : beradcrumb, # 面包屑导航
'page_skus' : page_skus, #当前页面的商品种类
'total_page' : total_page, # 总页数
'page_num' : page_num, # 当前页面
'sort' : sort, # 排序规则
'category_id' : category_id, # 商品id
}
return render(request, 'list.html', context)
def get(self, request, category_id, page_num):
"""
1.判断category_id
2.获取分类数据
3.获取面包屑数据
4.组织排序字段
5.分页
6.组织数据
7.返回相应
"""
# 1.判断category_id
try:
category = GoodsCategory.objects.get(pk=category_id)
except Exception as e:
return http.HttpResponseNotFound('分类数据错误')
# 2.获取分类数据
categories = get_categories()
# 3.获取面包屑数据
breadcrumb = get_breadcrumb(category)
# 4.组织排序字段
sort = request.GET.get('sort')
order_field = ''
if sort == 'price':
order_field = 'price'
elif sort == 'hot':
order_field = '-sales'
else:
sort = 'default'
order_field = 'create_time'
skus = SKU.objects.filter(category=category,
is_launched=True).order_by(order_field)
# 5.分页
paginator = Paginator(skus, per_page=5)
try:
page_num = int(page_num)
page_skus = paginator.page(page_num)
except Exception as e:
return http.HttpResponseNotFound('empty page')
#总页数
total_page = paginator.num_pages
# 6.组织数据
context = {
'categories': categories,
'breadcrumb': breadcrumb,
'sort': sort, # 排序字段
'category': category, # 第三级分类
'page_skus': page_skus, # 分页后数据
'total_page': total_page, # 总页数
'page_num': page_num, # 当前页码
}
# 7.返回相应
return render(request, 'list.html', context=context)
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):
"""提供商品列表页"""
# 判断category_id是否正确
try:
category = models.GoodsCategory.objects.get(id=category_id)
except models.GoodsCategory.DoesNotExist:
return http.HttpResponseNotFound('GoodsCategory does not exist')
# 查询商品频道分类
categories = get_categories()
# 查询面包屑导航
breadcrumb = get_breadcrumb(category)
# 接收sort参数：如果用户不传，就是默认的排序规则
sort = request.GET.get('sort', 'default')
# 按照排序规则查询该分类商品SKU信息
if sort == 'price':
# 按照价格由低到高
sort_field = 'price'
elif sort == 'hot':
# 按照销量由高到低
sort_field = '-sales'
else:
# 'price'和'sales'以外的所有排序方式都归为'default'
sort_field = 'create_time'
skus = models.SKU.objects.filter(category=category,
is_launched=True).order_by(sort_field)
# 创建分页器：每页N条记录
paginator = Paginator(skus, 5) # 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 persona_redirect(request, persona_id):
if persona_id == 0:
# Newer themes have persona_id == 0, doesn't mean anything.
return http.HttpResponseNotFound()
persona = get_object_or_404(Persona.objects, persona_id=persona_id)
try:
to = reverse('addons.detail', args=[persona.addon.slug])
except Addon.DoesNotExist:
# Would otherwise throw 500. Something funky happened during GP
# migration which caused some Personas to be without Addons (problem
# with cascading deletes?). Tell GoogleBot these are dead with a 404.
return http.HttpResponseNotFound()
return http.HttpResponsePermanentRedirect(to)
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 post(self, request, path):
github = request.user.github
if github is None:
logging.error("User does not have a github account")
return http.HttpResponseForbidden()
# only allow actions on hooks
if not HOOKS_MATCH.match(path):
logging.error("Bad path: %s", path)
return http.HttpResponseForbidden()
action = self.request.POST.get('action')
if action == "add":
data = {
"name": "web",
"active": True,
"events": ["push"],
"config": {
"url": "http://www.julython.org/api/v1/github",
"content_type": "form",
"insecure_ssl": "1"
}
}
elif action == "test":
data = ""
token = github.extra_data.get('access_token', '')
headers = {'Authorization': 'token %s' % token}
url = 'https://api.github.com/%s' % path
resp = requests.post(
url, data=json.dumps(data),
params=request.GET, headers=headers)
if resp.status_code == 404:
return http.HttpResponseNotFound()
resp.raise_for_status()
return http.HttpResponse(resp.text, content_type='application/json')
def download_file_stream(filepath, temp_dir=None):
"""
Returns `filepath` as a HttpResponse stream.
Deletes temp_dir once stream created if it exists.
"""
# If not found, return 404
if not os.path.exists(filepath):
return http.HttpResponseNotFound(_("File not found"))
filename = os.path.basename(filepath)
# Open file in binary mode
response = http.FileResponse(open(filepath, 'rb'))
mimetype = mimetypes.guess_type(filename)[0]
response['Content-type'] = mimetype
response['Content-Disposition'] = 'attachment; filename="' + filename + '"'
response['Content-Length'] = os.path.getsize(filepath)
# Delete temp dir if created
if temp_dir and os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
return response
def save_hours(request):
if not request.user.is_authenticated(): # XXX improve this
return {'error': 'Not logged in'}
if not request.POST.get('entry'):
return http.HttpResponseBadRequest("No entry parameter provided")
try:
entry = Entry.objects.get(pk=request.POST['entry'])
except Entry.DoesNotExist:
return http.HttpResponseNotFound("Not found")
if entry.user != request.user:
return http.HttpResponseForbidden("Not your entry")
from dates.forms import HoursForm
from dates.views import save_entry_hours, send_email_notification
form = HoursForm(entry, data=request.POST)
if form.is_valid():
total_hours, is_edit = save_entry_hours(entry, form)
success, email_addresses = send_email_notification(
entry,
'', # extra users to send to
is_edit=is_edit,
)
return {'ok': True}
else:
return {'form_errors': form.errors}
def get_price(request, product_slug):
quantity = 1
try:
product = Product.objects.get(active=True, slug=product_slug)
except Product.DoesNotExist:
return http.HttpResponseNotFound(simplejson.dumps(
('', _("not available"))),
mimetype="text/javascript")
prod_slug = product.slug
if request.POST.has_key('quantity'):
quantity = int(request.POST['quantity'])
if 'ConfigurableProduct' in product.get_subtypes():
cp = product.configurableproduct
chosenOptions = optionset_from_post(cp, request.POST)
pvp = cp.get_product_from_options(chosenOptions)
if not pvp:
return http.HttpResponse(simplejson.dumps(
('', _("not available"))),
mimetype="text/javascript")
prod_slug = pvp.slug
price = moneyfmt(pvp.get_qty_price(quantity))
else:
price = moneyfmt(product.get_qty_price(quantity))
if not price:
return http.HttpResponse(simplejson.dumps(('', _("not available"))),
mimetype="text/javascript")
return http.HttpResponse(simplejson.dumps((prod_slug, price)),
mimetype="text/javascript")
def render_in_page(request, template):
"""return rendered template in standalone mode or ``False``
"""
from leonardo.module.web.models import Page
page = request.leonardo_page if hasattr(
request, 'leonardo_page') else Page.objects.filter(
parent=None).first()
if page:
try:
slug = request.path_info.split("/")[-2:-1][0]
except KeyError:
slug = None
try:
body = render_to_string(
template,
RequestContext(
request, {
'request_path': request.path,
'feincms_page': page,
'slug': slug,
'standalone': True
}))
response = http.HttpResponseNotFound(body,
content_type=CONTENT_TYPE)
except TemplateDoesNotExist:
response = False
return response
return False
def render_to_response(self, ctx):
if not self.object.published:
return http.HttpResponseNotFound()
maxwidth = int(self.request.GET.get('maxwidth', 600))
maxheight = int(self.request.GET.get('maxheight', 600))
width = maxwidth
height = maxheight
embed_url = reverse(self.object.item_type + '_embed',
args=(self.object.rel_obj.pk, self.object.slug))
SITE_ROOT = site_root_url(self.request)
return http.JsonResponse({
'version':
'1.0',
'type':
'rich',
'html':
'<iframe width="{width}" height="{height}" src="{embed_url}"></iframe>'
.format(embed_url=SITE_ROOT + embed_url,
width=width,
height=height),
'width':
width,
'height':
height,
})
def get(self, request, page_num):
"""提供我的订单页面"""
# 获取登陆用户的所有订单
orders = request.user.orderinfo_set.all().order_by('-create_time')
# 遍历所有的订单
for order in orders:
# 绑定订单状态
order.status_name = OrderInfo.ORDER_STATUS_CHOICES[order.status - 1][1]
# 绑定支付方式
order.pay_method_name = OrderInfo.PAY_METHOD_CHOICES[order.pay_method - 1][1]
order.sku_list = []
# 获取该订单中所有的订单商品
order_goods = order.skus.all()
# 遍历所有的订单商品
for order_good in order_goods:
sku = order_good.sku
sku.count = order_good.count
sku.amount = sku.price * sku.count
order.sku_list.append(sku)
# 分页
page_num = int(page_num)
try:
paginator = Paginator(orders, 2)
page_orders = paginator.page(page_num)
total_page = paginator.num_pages
except EmptyPage:
return http.HttpResponseNotFound('找不到该页信息')
context = {
'page_orders': page_orders,
'total_page': total_page,
'page_num': page_num
}
return render(request, 'user_center_order.html', context)
def public(request, uuid):
area = get_object_or_404(umodels.Area, uuid=uuid)
if area.expired:
return http.HttpResponseNotFound("Requested area has expired")
if request.method == "POST":
form = UploadForm(request.POST, request.FILES)
if form.is_valid():
f = form.save(commit=False)
f.area = area
f.save()
else:
form = UploadForm()
files = []
for f in area.files.order_by("file"):
files.append({
"id": f.id,
"url": f.file.url,
"name": os.path.basename(f.file.name),
"size": f.file.size,
})
return render(request, "uploads/public.html", {
"area": area,
"form": form,
"files": files,
})
def fail_with404(request, error_msg=None):
"""
custom 404 method that enable 404 template even in debug mode (discriminate from real 404),
Raise no exception so call it with return
:param request: Django request object
:type request: http.HttpRequest
:param error_msg: The message to display on the 404 page
:type error_msg: str
:return: custom 404 page
:rtype: http.HttpResponseNotFound
"""
t = loader.get_template('404.html')
if type(error_msg) is not list:
error_msg = [error_msg]
rq_path = request.path if request is not None else ''
logger.warning('404 %s: %s' % (rq_path, error_msg))
return http.HttpResponseNotFound(t.render(RequestContext(request, {
'request_path': rq_path,
'messages': error_msg,
})))
def get(self, request, page_num):
"""提供我的订单页面"""
user = request.user
# 查询订单
orders = user.orderinfo_set.all().order_by('-create_time')
# 遍历所有订单
for order in orders:
order.status_name = OrderInfo.ORDER_STATUS_CHOICES[order.status -
1][1]
order.pay_method_name = OrderInfo.PAY_METHOD_CHOICES[
order.pay_method - 1][1]
order.sku_list = []
# 查询订单商品
order_goods = order.skus.all()
for order_good in order_goods:
sku = order_good.sku
sku.count = order_good.count
sku.amount = sku.price * sku.count
order.sku_list.append(sku)
page_num = int(page_num)
try:
paginator = Paginator(orders, constants.ORDERS_LIST_LIMIT)
page_orders = paginator.page(page_num)
total_page = paginator.num_pages
except EmptyPage:
return http.HttpResponseNotFound('订单不存在')
context = {
"page_orders": page_orders,
'total_page': total_page,
'page_num': page_num,
}
return render(request, 'user_center_order.html', context)
