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)