def getnewtopic(request):
if request.user.is_authenticated:
if request.user.is_staff or request.user.is_superuser:
form = categoryForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
instance.save()
messages.success(request, 'Created a new topic successfully')
return redirect('topics')
return render(request, 'blog/create_topic.html', {'form': form})
else:
raise Http404('You are not authorized to this page')
else:
return redirect('login')
def search_target(request):
start = datetime.now()
if request.method != 'GET':
raise Http404()
key_word = request.GET.get('keyword')
if not key_word:
return render(request, 'search.html')
choice = request.GET.get('choice')
if choice == "movie":
return search_movie(request, key_word, start)
if choice == "actor":
return search_actor(request, key_word, start)
if choice == "comment":
return search_comment(request, key_word, start)
def post_update(request, slug):
if not request.user.is_authenticated:
return Http404()
post = get_object_or_404(Post, slug=slug)
form = PostForm(request.POST or None, request.FILES or None, instance=post)
if request.method == "POST":
if form.is_valid():
post = form.save()
messages.success(request, "Post updated succesfully")
return HttpResponseRedirect(post.get_absolute_url())
context = {
'form': form
}
return render(request, "post/form.html", context)
def post_create(request):
if not request.user.is_authenticated():
return Http404()
form = postForm(request.POST or None,request.FILES or None)
if form.is_valid():
savedPost = form.save(commit=False)
savedPost.user = request.user
savedPost.save()
messages.success(request,"başarılı oluşturuldu")
return HttpResponseRedirect(savedPost.get_absolute_url())
context={'form':form}
return render(request,'postsFiles/create.html',context)
def dislike_dish(request):
if request.method == 'POST':
dish_name = request.POST['dish_name']
username = request.POST['username']
user = User.objects.filter(username=username)[0]
dish = Dish.objects.filter(name__contains=dish_name)
if len(dish) == 1:
dish = dish[0]
# user.liked_dishes.add(dish, through_defaults={'score': score})
user.liked_dishes.remove(dish)
return HttpResponse('Successfully disliked')
else:
return Http404()
def post_create(request):
if not request.user.is_authenticated():
return Http404()
form = PostForm(request.POST or None, request.FILES or None)
if form.is_valid():
post = form.save(commit=False) #veritabanına kayıt eder
post.user = request.user
post = form.save()
messages.success(request, 'BAŞARILI')
return HttpResponseRedirect(post.get_absolute_url())
context = {
'form': form,
}
return render(request, 'post/form.html', context)
def activate(request, uid, token):
try:
usuario = get_object_or_404(Usuario, pk=uid)
except:
raise Http404("No se encontró el usuario")
if usuario is not None and activation_token.check_token(usuario, token):
usuario.is_active = True
ruta_certificado = Generator.generate_key(usuario.username)
usuario.certificado = ruta_certificado
usuario.save()
return HttpResponse(
"<h2>Cuenta activada. Ahora puedes iniciar sesión haciendo <a href='/login'>click aquí</a></h2>"
)
else:
return HttpResponse("<h3>Link de activación inválido</h3>")
def createTopic(request):
if request.user.is_authenticated:
if request.user.is_staff or request.user.is_superuser:
form = categoryForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
instance.save()
messages.success(request, 'Category successfully added')
return redirect('blog:category')
context = {'form': form}
return render(request, 'create_topic.html', context)
else:
raise Http404('You are not authorized to access this page')
else:
return redirect('blog:login')
def get_file(request, ref_id):
if request.user.is_authenticated:
ref = get_object_or_404(Ref, pk=ref_id)
if ref.library.user.username != request.user.username:
raise Http404("用户权限错误！")
pdf_file_path = ref.pdf.pdf_file.path
with open(pdf_file_path, 'rb') as file:
response = HttpResponse(file.read(),
content_type='application/pdf')
response[
'Content-Disposition'] = 'inline; filename="' + ref.pdf.pdf_file.name + '"'
return response
return redirect('/')
def user_profile(username):
user = get_object_or_404(User.objects.select_related('userinfo', 'userinfo__avatar'), username=username)
if not user.is_active:
raise Http404("Deactivated user.")
follow_counts = following_models.counts(user)
return {
'user': user.details(),
'bio': user.userinfo.bio_text,
'quest_completion_count': Quest.completed_by_user_count(user),
'follower_count': follow_counts['followers'],
'following_count': follow_counts['following'],
}
def message(request):
if request.method == "POST":
print 'got a requesst'
post = request.POST
email = post.get('email')
number = post.get('number')
name = post.get('name')
message = post.get('msg')
Message.objects.create(name=name,email=email,mobileNumber=number,message=message)
# messages.success(request,"Message recorded!, we'll contact you soon",fail_silently=True)
response_data = {}
else:
raise Http404('not allowed')
def detail(request, restoid):
try:
resto_id = Restaurant.objects.get(pk=restoid)
menus = Menu.objects.all().filter(rm_id_id=resto_id.id)
fotos = Photo.objects.all().filter(rm_id_id=resto_id.id)
reviews = Review.objects.all().filter(rm_id_id=resto_id.id)
except Restaurant.DoesNotExist:
raise Http404(
f"Restaurant dengan entry nomor {restoid} tidak tersedia.")
return render(request, 'detail.html', {
'resto_id': resto_id,
'menus': menus,
'fotos': fotos,
'reviews': reviews
})
def create_team(request):
"""
Creates a team. It doesn't relates member and teams, so users have to use the really cool search feature.
"""
if request.method == 'POST':
email = request.session.get('email', None)
team_name = request.POST.get('team_name', None)
team = Team(name=team_name)
team.save()
message = "Team created, please use the cool search feature and assign yourself to the team"
messages.add_message(request, messages.INFO, message)
return redirect('teamsapp:teams')
else:
raise Http404('Not allowed')
def download_file(key):
"""Returns an HttpResponse to download the corresponding file"""
file_path = get_file_path(key)
metadata_path = get_metadata_path(key)
if not os.path.exists(file_path):
raise Http404()
with open(metadata_path) as f:
metadata = json.load(f)
content_type = metadata.get("Content-Type", 'application/octet-stream')
with open(file_path, 'r') as f:
response = HttpResponse(f.read(), content_type=content_type)
file_name = os.path.basename(os.path.dirname(file_path))
response['Content-Disposition'] = 'attachment; filename=' + file_name
return response
def get_vk_bot_instance(request, bot_slug):
print(bot_slug)
try:
bot = VkBot.objects.get(bot_slug=bot_slug)
except VkBot.DoesNotExist:
print('does not exist')
raise Http404('bot does not exist')
print(bot.bot_place)
print(request.user)
if bot.bot_place != request.user:
print('403')
return HttpResponse(status=403, content_type="application/json")
else:
data = serialize('json', [bot])
return HttpResponse(data, content_type="application/json")
def get_object(self):
try:
visualdatas = super().get_queryset()
filter_date = datetime.datetime.strptime(self.kwargs['date'],
"%Y-%m-%d").date()
qs = visualdatas.filter(
crawlerDate__year=filter_date.year,
crawlerDate__month=filter_date.month,
)
d = {_.crawlerDate.day: _ for _ in qs}
return d[min(d.keys(), key=lambda _: abs(_ - filter_date.day))]
except Exception as e:
print(e, file=sys.stderr)
raise Http404(
"{}".format(e)) # -[o] update to DRF response type later
def download(request):
payinfo_id = request.GET.get('payinfo_id')
# 返回模型
order = PayinfoOrder.objects.filter(payinfo_id=payinfo_id,buyer=request.user,status=2).first()
if order:
payinfo = order.payinfo
path = payinfo.path
fp = open(os.path.join(settings.MEDIA_ROOT,path),'rb')
response = FileResponse(fp)
# /a/xx.png = ['',a,xx.png]
response['Content-Type'] = 'image/jpeg'
response['Content-Disposition'] = 'attachment;filename="%s"'%path.split("/")[-1]
return response
else:
return Http404()
def get(self, request, *args, **kwargs):
if request.is_ajax():
sku_id = int(request.GET['id'])
sku = SKU.objects.get(id=sku_id)
action = request.GET['action']
status = self.get_action_status(action, sku_id)
batch = sku.batch
product = sku.product
context = {'is_liked': status, 'batch': batch, 'product': product}
html = render_to_string(self.template_name, context)
return HttpResponse(html)
raise Http404()
def post_update(request,id):
if not request.user.is_authenticated:
return Http404()
post_det = get_object_or_404(Post,id=id)
form_cr = PostForm(request.POST or None, request.FILES or None,instance=post_det)
if form_cr.is_valid():
form_cr.save()
messages.success(request,'Your post has been updated succesfully')
return HttpResponseRedirect(post_det.get_absolute_url())
context = {
'form':form_cr
}
return render(request, 'post/form.html',context)
def post(self,request):
queryset = models.Google2Auth.objects.filter(Q(user__username=request.data["username"]) | Q(user__email=request.data["username"]))
if queryset.exists():
raise Http404("已经绑定令牌,绑定失败")
serializer = googleSerializer(data=request.data)
serializer.is_valid(raise_exception=True)
user = models.UserProfile.objects.get(Q(email=request.data["username"]) | Q(username=request.data["username"]))
login(request, user)
base_32_secret = base64.b32encode(codecs.decode(codecs.encode('{0:020x}'.format(random.getrandbits(80))), 'hex_codec'))
totp_obj = googletotp.TOTP(base_32_secret.decode("utf-8")) # 实例化类
qr_code = re.sub(r'=+$', '', totp_obj.provisioning_uri(request.user.email))
models.Google2Auth.objects.create(user=user)
key = str(base_32_secret,encoding="utf-8")
queryset.update(key=key)
return Response({"success": True, "msg": "绑定成功","results": {"qr_code": qr_code}}, status=status.HTTP_201_CREATED)
def form_valid(self, form):
p = ElearningProgram.objects.get(slug = self.kwargs['slug'])
s = Semester.objects.filter(program = p)
if s.count() != 6 :
if s:
form.instance.order = s.last().order + 1
else:
form.instance.order = 1
form.instance.name = _("Semester")
form.instance.program_id = p.id
instance = form.save()
else:
raise Http404("You already have 6 Semester")
return super(SemesterCreateView, self).form_valid(form)
def verificar_inscripcion(request):
if request.method == 'POST':
cantidad_alumnos = int(request.POST['alumnosCount'])
inscripciones = []
for i in range(1, cantidad_alumnos + 1):
prefix = 'alumno-' + str(i) + '-inscripcion'
form = FormularioInscripcion(request.POST, prefix=prefix)
inscripciones.append({
"alumno": i,
"valid": form.is_valid(),
"errors": form.errors
})
return JsonResponse(inscripciones, safe=False)
raise Http404()
def become(request):
if not settings.HIJACK_ENABLE:
raise Http404(_('Hijack feature is not enabled.'))
if not request.user.is_superuser:
raise PermissionDenied()
id = request.POST.get('user_pk')
if request.POST and id:
target_user = User.objects.get(pk=id)
if target_user.is_superuser:
raise PermissionDenied()
return AcquireUserView.as_view()(request)
return redirect('users:account')
def edit(request, selection):
#If the user has submitted a change, update it, else display the current page in markdown format.
if request.method == "POST":
util.save_entry(selection, request.POST.get("data"))
return redirect('entry', selection=selection)
else:
if util.get_entry(selection) != None:
context = {
"selection": selection,
"data": util.get_entry(selection),
"random": random.choice(util.list_entries())
}
return render(request, "encyclopedia/edit.html", context)
else:
raise Http404(request, f"a page for {selection} does not exist.")
def getQuestionByLevel(request, level):
player = get_object_or_404(Player, user=request.user)
level = int(level)
if level > player.level:
raise Http404()
ques = get_object_or_404(Question, level=level)
context = {
'question': ques,
'player': player,
'rank': Player.rank(player),
'social_account': SocialAccount.objects.get(user=player.user),
'level_range': range(0, player.level + 1),
'showAnswerWindow': True if level == player.level else False
}
return render(request, "question/index.html", context)
def get(self, request):
try:
paginator = PageNumberPagination()
paginator.page_size = 100
query_param = self.request.query_params.get('q', None)
from_date = self.request.query_params.get(
'from_date',
dt.date.today().strftime("%Y-%m-%d"))
to_date = self.request.query_params.get('to_date', from_date)
order_field = self.request.query_params.get('order', None)
order_type = self.request.query_params.get('type', 'ASC')
returned_fields = self.request.query_params.get('fields', None)
group_fields = self.request.query_params.get('group_fields', None)
cpi = self.request.query_params.get('cpi', 0)
if query_param:
dataset = DatasetModel.objects.filter(
Q(channel__icontains=query_param)
| Q(country__icontains=query_param)
| Q(os__icontains=query_param))
else:
dataset = DatasetModel.objects.all()
data_serializer = DataSerializer()
self.handle_returned_fields(returned_fields, dataset,
data_serializer)
dataset = self.get_data_within_a_daterange(from_date, to_date,
dataset)
dataset = self.get_data_ordered(order_field, order_type, dataset)
cpi_value = self.handle_cpi_value(cpi, dataset)
# Only aggregated by Impressions and Clicks as test case.
aggs = self.get_aggregated_values(group_fields, dataset)
result_page = paginator.paginate_queryset(dataset, request)
serializer = DataSerializer(result_page, many=True)
data = paginator.get_paginated_response(serializer.data)
res = {
'res': data.data,
'total_cpi': cpi_value,
'aggregations': aggs
}
return Response(res)
except Exception as e:
print(e)
raise Http404('Requested is failed with error {}'.format(
e.__doc__))
def seat_query(request):
if request.method == "GET":
match_id = request.GET.get('match')
bay = request.GET.get('bay')
match_book = Schedule_Match.objects.get(pk=match_id)
try:
with open('static/arrange.json', 'r') as file:
seat_arrange = js.load(file)
except:
raise Http404("Json Error")
Seats.delete_temp_allocated()
occ_seats = Seats.objects.filter(match=match_book)
occ_seats = [x.seats[1:] for x in occ_seats if x.seats[0] == bay]
#for x in occ_seats:
# print(x)
return render(
request, 'Seat_arrange.html', {
"data": seat_arrange,
'match_book': match_book,
'bay': bay,
"unavilable_seats": occ_seats
})
else:
selected_seats = request.POST['selected_seats']
selected_seats = selected_seats.split(',')
request.session['selected_seats'] = selected_seats
match_id = request.POST['match_id']
match_book = Schedule_Match.objects.get(pk=match_id)
email_id = request.session['email_id']
account = Accounts.objects.get(email_id=email_id)
bay = request.POST['bay']
level_count = [x[0] for x in selected_seats]
scount = set(level_count)
a = {}
for x in scount:
a[x] = level_count.count(x)
price = a.get('1', 0) * 250 + a.get('2', 0) * 450 + a.get('3', 0) * 550
gst = 0.09 * price
total = price + gst + gst
pay = [price, gst, total]
return render(
request, 'payment.html', {
'selected_seats': selected_seats,
'match_book': match_book,
'account': account,
'bay': bay,
'pay': pay
})
def table_change(request, app_name, table_name, obj_id, embed=False):
# print("table change:",app_name,table_name ,obj_id)
if app_name in site.enabled_admins:
if table_name in site.enabled_admins[app_name]:
admin_class = site.enabled_admins[app_name][table_name]
# print(enabled_admins[table_name])
obj = admin_class.model.objects.get(id=obj_id)
# print("obj....change",obj)
fields = []
for field_obj in admin_class.model._meta.fields:
if field_obj.editable:
fields.append(field_obj.name)
for field_obj in admin_class.model._meta.many_to_many:
fields.append(field_obj.name)
# print('fields', fields)
model_form = forms.create_form(admin_class.model,
fields,
admin_class,
request=request)
if request.method == "GET":
form_obj = model_form(instance=obj)
elif request.method == "POST":
# print("post:", request.POST)
form_obj = model_form(request.POST, instance=obj)
if form_obj.is_valid():
form_obj.validate_unique()
if form_obj.is_valid():
form_obj.save()
return_data = {
'form_obj': form_obj,
'model_verbose_name': admin_class.model._meta.verbose_name,
'model_name': admin_class.model._meta.model_name,
'app_name': app_name,
'admin_class': admin_class,
'enabled_admins': site.enabled_admins
}
if embed:
return return_data
else:
return render(request, 'swing/table_change.html', return_data)
else:
raise Http404("url %s/%s not found" % (app_name, table_name))
def post_update(request, slug):
if not request.user.is_authenticated:
return Http404()
posts_update = get_object_or_404(post, slug=slug)
form = PostForm(request.POST or None,
request.FILES or None,
instance=posts_update)
if form.is_valid():
form.save()
messages.success(request,
'Başarılı bir şekilde güncellediniz.',
extra_tags='mesaj-basarılı')
return HttpResponseRedirect(posts_update.get_absolute_url())
context = {'form': form}
return render(request, 'post/form.html', context)
def create_view(request):
if not request.user.is_authenticated:
return Http404()
form = PostForm(request.POST or None, request.FILES or None)
if form.is_valid():
post = form.save(commit=False)
post.author = request.user
post = form.save()
messages.success(request,
"POst created successfully",
extra_tags='msg')
return HttpResponseRedirect(post.get_absolute_url())
context = {'form': form}
return render(request, 'post/form.html', context)
