def revokeAccess(request):
'''
Revokes access to the application from Loggly for a user's account. All
token credentials in the cookie and session are purged.
Keyword arguments:
request -- the request object.
Return:
A redirect back to the rendering request form.
'''
response = HttpResponseRedirect('/process?r=1')
# Remove the set cookie.
if "afLoggly" in request.COOKIES:
response.delete_cookie(key = "afLoggly")
# Purge any authentication data in session.
keys = ['key', 'secret,' 'subdomain']
for key in keys:
if key in request.session:
request.session.pop(key)
return response
def Register(request):
if request.method=='POST':
print request.POST
rf=RegisterForm(request.POST,request.FILES)
print rf,"rf.is_valid()===",rf.is_valid(),rf.cleaned_data['image']
if rf.is_valid():
rg_user=User()
rg_bbs_user=models.BbsUser()
print '=============================================================='
rg_user.username=rf.cleaned_data['username']
rg_user.password=rf.cleaned_data['password']
rg_user.email=rf.cleaned_data['email']
rg_user.first_name=rf.cleaned_data['firstname']
rg_user.last_name=rf.cleaned_data['lastname']
rg_user.date_joined=datetime.datetime.now()
print "rg_user:"******"保存失败，请重试！"})
return render(request,'newbbs/register.html')
def signin_view(request):
if request.method == "GET":
mobile = request.COOKIES.get("mobile", "")
return render(request, "account/signin.html", {
"mobile": mobile,
})
elif request.method == "POST":
mobile = request.POST['mobile']
password = request.POST['password']
if mobile is None or password is None:
error = "Mobile or Password is empty."
else:
next = request.POST.get('next', "/")
if not next:
next = "/"
response = HttpResponseRedirect(next)
response.set_cookie(key="mobile", value=mobile, max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False)
user = authenticate(username=mobile, password=password)
if user:
if user.is_active:
login(request, user)
print "User is valid, active and authenticated"
return response
else:
error = "Please active your account before trying to login again."
else:
error = "The username and password were incorrect."
return HttpResponse(status=400, content=error)
def Login(request):
if request.method=='POST' and request.POST.has_key('username') and request.POST.has_key('password'):
username = request.POST['username']
password = request.POST['password']
#print username,password
#result_login=models.BbsUser.objects.filter(user__username=username,user__password=password)
#print 'result_login',result_login
user = authenticate(username=username, password=password)
print 'user:'******'username'] = username
response=HttpResponseRedirect('/')
response.set_cookie('username',username,3600)
#request.session
# Redirect to a success page.
return response
else:
return render(request,'newbbs/login.html',{'error':"此用户未激活"})
else:
return render(request,'newbbs/login.html',{'error':"用户名或密码有误，请重试！"})
return render(request,'newbbs/login.html')
def ingresar(request):
mensaje=""
if not request.user.is_anonymous():
return HttpResponseRedirect('/home')
if request.method == 'POST':
formulario = AuthenticationForm(request.POST)
if formulario.is_valid:
usuario = request.POST['username']
clave = request.POST['password']
acceso = authenticate(username=usuario,password=clave)
if acceso is not None:
if acceso.is_active:
agregar_visita(usuario)
login(request, acceso)
response = HttpResponseRedirect('/home')
response.set_cookie("usuario",usuario)
response.set_cookie("use",acceso)
return response
else:
mensaje=mensajes_no_activo
else:
mensaje=mensajes_error_login
else:
mensaje=mensajes_error_login
else:
formulario = AuthenticationForm()
return render_to_response('ingresar.html',{'formulario':formulario,'mensaje':mensaje},context_instance=RequestContext(request))
def login_page(request):
if request.user.is_authenticated():
response = HttpResponseRedirect('/diary/')
return response
if request.method == 'POST':
uf = UserForm(request.POST)
if uf.is_valid():
username = uf.cleaned_data['username']
password = uf.cleaned_data['password']
user = authenticate(username=username,password=password)
login(request, user)
if request.META.has_key('HTTP_CF_CONNECTING_IP'):
logInIP = request.META['HTTP_CF_CONNECTING_IP']
else:
logInIP = request.META['REMOTE_ADDR']
logInTime = datetime.datetime.now()
logOutTime = datetime.datetime.now()
UserAgent = str(parse(request.META.get('HTTP_USER_AGENT')))
try:
UItem= UserLogInfo.objects.create(user = user,
logInIP = logInIP,
logInTime = logInTime,
logOutTime = logOutTime,
UserAgent = UserAgent)
except:
pass
response = HttpResponseRedirect('/diary/')
LogID = UItem.pk
response.set_cookie('LogID',LogID,3600)
return response
else:
uf = UserForm()
else:
uf = UserForm()
return render_to_response('login_page.html',locals(),context_instance=RequestContext(request))
def login(request):
auth = request.COOKIES.get('auth')
if auth: #already logged in, redirect to home page
return HttpResponseRedirect(reverse("displayCells"))
if request.method == 'GET':
l_form = LoginForm()
next = request.GET.get('login') or reverse('displayCells')
return render(request, 'login.html', {'form': l_form})
f = LoginForm(request.POST)
if not f.is_valid():
# bogus form post, send them back to login page and show them an error
messages.error(request, 'You must fill out all fields')
return HttpResponseRedirect('/login/')
email = f.cleaned_data['email']
password = f.cleaned_data['password']
next = reverse('displayCells') #reverse takes name of the view and returns the URL of the view
#send typed email and password to exp level
resp = requests.post('http://expul:8000/api/v1/login_exp_api/', data={"email": email, "password": password}).json()
if not resp or not resp[0]['pk']: #no student with that username/password, send back to login page with error
messages.error(request, 'Invalid username and/or password.')
return HttpResponseRedirect(reverse('login'))
# logged them in. set their login cookie and redirect to back to wherever they came from
authenticator = resp[0]['pk']
response = HttpResponseRedirect(next)
response.set_cookie("auth", authenticator)
return response
def LoginOut(request):
#print 'user:'******'username']
del request.session['username'] #删除session
response=HttpResponseRedirect('/login/')
response.delete_cookie('username')
#logout(request.user)
return response
def post(self, request):
"""
Process form data on POST requests
"""
auth_form = AuthenticationForm(data=request.POST)
if auth_form.is_valid():
login(request, auth_form.get_user())
# obtain JW token
jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
payload = jwt_payload_handler(auth_form.get_user())
user_token = jwt_encode_handler(payload)
response = HttpResponseRedirect(reverse('home'))
response.set_cookie('user_token', user_token)
response.set_cookie('user_id', request.user.id)
request.session.set_expiry(600)
return response
else:
for key in auth_form.errors:
for error in auth_form.errors[key]:
messages.add_message(request, messages.INFO, error)
args = {}
args.update(csrf(request))
args.update({'form': RegisterForm})
return render(
request, 'authenticate.html', {'form': RegisterForm}
)
def add_product_to_cart(request):
context={}
response = HttpResponseRedirect('/cart/')
product_id = request.POST['product_id']
if (request.COOKIES.get(COOKIES_ID)):
cart = Cart.objects.get(
id=request.COOKIES.get(COOKIES_ID)
)
else:
cart = Cart.objects.create(
total_amount=0
)
cart_id = cart.id
cart.total_amount += Product.objects.get(id=product_id).price
cart.save()
cart_element = CartElement.objects.create(
product=Product.objects.get(
id=product_id
),
cart=Cart.objects.get(
id=cart_id
),
size=Size.objects.filter(
size = request.POST['size']
).first()
)
size = Size.objects.filter(
size = request.POST['size'],
available=True
).first()
size.available = False
size.save()
cart_element_id = cart_element.id
response.set_cookie(
key=COOKIES_ID,
value=str(cart_id),
max_age=10000000
) # неделя
available_sizes = Size.objects.filter(
available=True,
product=Product.objects.get(id=product_id)
).count()
if (available_sizes == 0):
product = Product.objects.get(
id=product_id
)
product.available = False
product.save()
return response
def Inst(request):
if request.method == 'GET':
contestName=request.GET.get('name')
response= HttpResponseRedirect("hi")
response = render_to_response('Instructions.html',{'contest':Contests.objects.get(contestName=contestName)},context_instance=RequestContext(request))
response.set_cookie('contestName')
return response
else:
print 'form invalid so entered here'
return render_to_response('TakeExam.html',{'contest_var':Contests.objects.all()},context_instance=RequestContext(request))
def set_language(request):
'''
Set language cookie, redirect to requested page
'''
lang = request.GET.get('lang', None)
response = HttpResponseRedirect(request.META["HTTP_REFERER"])
if lang == "ru":
response.set_cookie(key="lang", value="ru", max_age=365*24*60*60, expires=None, path='/')
else:
response.set_cookie(key="lang", value="en", max_age=365*24*60*60, expires=None, path='/')
return response
def set_language(request, lang_code='en'):
"""sets the application's language and redirects back to the calling template"""
original_url = request.META.get('HTTP_REFERER', None)
response = HttpResponseRedirect(original_url)
if hasattr(request, 'session'):
if lang_code and check_for_language(lang_code):
request.session['django_language'] = lang_code
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
return response
def logout(request):
try:
response = HttpResponseRedirect("/case/login")
response.delete_cookie("username")
response.delete_cookie("password")
session_key = request.session.session_key
Session.objects.get(session_key=session_key).delete()
return response
except:
pass
return HttpResponseRedirect("/case/login/")
def login_handle(request):
# 接收请求信息
post = request.POST
uname = post.get('username')
upwd = post.get('pwd')
#这里接收的参数'jizhu'为从login.html中接收的，默认为勾选了则为1，那么就不会用后面的默认值0
jizhu = post.get('jizhu', 0)
# 根据用户名查询对象，这里用filter，如果查不到会返回[]
users = UserInfo.objects.filter(uname=uname)
# print uname
# 判断如果未查到则用户名错，查到再判断密码是否正确，正确则转到用户中心
if len(users) == 1:
s1 = sha1()
s1.update(upwd.encode("utf-8"))
#登录带cookie值 必须 red = HttpResponseRedirect red.set_cookie renturn red
if s1.hexdigest() == users[0].upwd:
red = HttpResponseRedirect('/user/info') #转到用户中心
count = CartInfo.objects.filter(user_id=users[0].id).count()
#另外一种写法
#url = request.COOKIES.get('url', '/') 这里的'/'是默认值，表示url中没设定时，转到'/'
#red=HttpResponseRedirect(url)
# 记住用户名，就是如果选上记住用户名勾选框，就把用户名记在cookie中
#set_cookie()是HttpResponse中的方法，而HttpResponseRedirect继承了HttpResponse.
if jizhu != 0:
red.set_cookie('uname', uname)
#如果不勾选记住用户名，就把uname值清空，max_age=-1表示立即过期，
else:
red.set_cookie('uname', '', max_age=-1)
#状态保持中的session存储方式的使用，对于使用频率比较高的数据可以使用
#存储方式包括cookie、session，会话一般指session对象
#使用cookie，所有数据存储在客户端，注意不要存储敏感信息
#推荐使用sesison方式，所有数据存储在服务器端，在客户端cookie中存储session_id
#状态保持的目的是在一段时间内跟踪请求者的状态，可以实现跨页面访问当前请求者的数据
request.session['user_id'] = users[0].id
request.session['user_name'] = uname
request.session['count'] = count
return red #记住最后必须return
#这里表示密码不对的处理
else:
context = {'title': '用户登录', 'error_name': 0, 'error_pwd': 1, 'uname': uname}
return render(request, 'df_user/login.html', context)
#这里表示没查到用户名，表明用户名错误，这里error_name设为1
else:
context = {'title': '用户登录', 'error_name': 1, 'error_pwd': 0, 'uname': uname }
#error_name=1传到login.html中，在里面会对应的代码显示用户名错误
return render(request, 'df_user/login.html', context)
def add_like(request,article_id):
ctime = Article.objects.get(id=article_id).stime
hash_id = hashlib.sha1(str(ctime)).hexdigest()
try:
if hash_id in str(request.COOKIES.get(article_id)):
return HttpResponseRedirect('/blog/%s/like.html'%article_id)
else:
article = Article.objects.get(id=article_id)
article.likes +=1
article.save()
response = HttpResponseRedirect('/blog/%s/'%article_id)
response.set_signed_cookie(article_id,value=hash_id,max_age=86400)
return response
except models.Article.DoesNotExist:
raise Http404
def login_check_user(request):
'''验证用户
'''
username = request.POST['username']
password = request.POST['password']
try:
theuser = AdminUser.objects.get(name=username)
except Exception:
theuser = None
if not theuser:
return render_to_response('login.html',{'errormsg':USER_ERROR})
if not theuser.check_password(password):
return render_to_response('login.html',{'errormsg':PASSWORD_ERROR})
response = HttpResponseRedirect("/main")
response.set_cookie('login_user', username,max_age=600)
return response
def switch_lang(request):
next = request.REQUEST.get('next', None)
if not next:
next = request.META.get('HTTP_REFERER', None)
if not next:
next = '/'
response = HttpResponseRedirect(next)
if request.method == 'GET':
lang_code = request.GET.get('lang_code', None)
if lang_code and check_for_language(lang_code):
if hasattr(request, 'session'):
request.session['django_language'] = lang_code
else:
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, lang_code)
return response
def login(request):
if request.method == 'POST':
print(request.POST)
form_value = UserForm(request.POST)
if form_value.is_valid():
#获取表单用户密码
username = form_value.cleaned_data['username']
password = form_value.cleaned_data['password']
#获取的表单数据与数据库进行比较
user = User.objects.filter(username__exact = username,password__exact = password)
if user:
#比较成功，跳转index
response = HttpResponseRedirect('/cmdb/home/')
#将username写入浏览器cookie,失效时间为3600
response.set_cookie('username',username,3600)
# logger.logger.info("%s loggin !"%username)
return response
else:
#比较失败，还在login
return HttpResponseRedirect('/cmdb/login/')
else:
form_value = UserForm()
return render_to_response('login.html')
def delete(request, oid):
order = Order.objects.filter(id=oid)
order.delete()
return HttpResponseRedirect(reverse('show_order'))
def user_del(request, ids):
if ids:
get_user_model().objects.filter(id=ids).delete()
return HttpResponseRedirect(reverse('user_list'))
def signout(request):
logout(request)
return HttpResponseRedirect(reverse('homepage'))
def logout(request):
auth.logout(request)
return HttpResponseRedirect(reverse('main'))
def where_next(request):
"""Simple redirector to figure out where the user goes next."""
if request.user.user_type=="AUTHOR":
return HttpResponseRedirect(reverse('author-profile'))
elif request.user.user_type=="EDITOR":
return HttpResponseRedirect(reverse('editor-profile'))
def delete(self, request, *args, **kwargs):
self.object = self.get_object()
self.object.is_active = False
self.object.save()
return HttpResponseRedirect(self.get_success_url())
def get_success_url(self):
return HttpResponseRedirect(reverse('CropManagement:farm_detail',args=[self.kwargs['pk']]))
def payroll_invoice_delete(request, dk):
instance = get_object_or_404(PayrollInvoice, id=dk)
instance.delete()
messages.success(request,
'The %s invoice is deleted!' % instance.person.title)
return HttpResponseRedirect(reverse('billings:payroll_page'))
def formDB(request):
if request.method == 'POST':
form = EIF(request.POST)
if form.is_valid():
form.save()
return HttpResponseRedirect('/dblayer/show/')
def vacation_update(request, pk):
instance = get_object_or_404(Vacation, id=pk)
instance.status = True
instance.save()
return HttpResponseRedirect(reverse('billings:vacation'))
def checkout(request):
if request.is_ajax:
if (request.GET):
delivery_charge = request.GET.get('dlvry')
sub_total = request.GET.get('sbtotal')
district = request.GET.get('dst')
area = request.GET.get('area')
print(area)
try:
the_id = request.session['cart_id']
cart = Cart.objects.get(id=the_id)
except:
the_id = None
return HttpResponseRedirect(reverse('viewCart'))
try:
new_order = Order.objects.get(cart=cart)
except Order.DoesNotExist:
new_order = Order(cart=cart)
new_order.user = request.user
new_order.order_id = id_generator()
except:
HttpResponseRedirect(reverse('viewCart'))
if new_order.status == "Finished":
del request.session['cart_id']
del request.session['item_count']
##Update order DB
new_order.coupon_discount = cart.coupon_discount
new_order.sub_total = float(sub_total)
new_order.delivery_charge = float(delivery_charge)
new_subtotal = float(new_order.sub_total)
new_delivery = float(delivery_charge)
new_coupon = float(new_order.coupon_discount)
raw_total = (new_subtotal + new_delivery) - new_coupon
new_order.final_total = float(raw_total)
new_order.area = area
new_order.district = district
new_order.save()
discount = {}
total_price = 0
total_discount = 0
cart_items = cart.cartitem_set.all()
for i in range(len(cart_items)):
item = cart_items[i].product.id
price = cart_items[i].product.price
total_price = total_price + price
sale = cart_items[i].product.sale
less = price - sale
total_discount = total_discount + less
if (price > 0):
discount[item] = int((less / price) * 100)
else:
discount[item] = 0
if (total_price > 0):
percent_discount = int((total_discount / total_price) * 100)
else:
percent_discount = 0
discount["total_discount"] = percent_discount
context = {'cart': cart, 'order': new_order, 'discount': discount}
else:
context = locals()
template = "order/order.html"
return render(request, template, context)
def logout_user(request):
logout(request)
return HttpResponseRedirect(reverse('home'))
def gitlabcontainerscan_vuln_data(request):
"""
:param request:
:return:
"""
username = request.user.username
jira_url = ''
jira = jirasetting.objects.filter(username=username)
for d in jira:
jira_url = d.jira_server
if request.method == 'GET':
scan_id = request.GET['scan_id']
test_name = request.GET['test_name']
else:
scan_id = None
test_name = None
if request.method == "POST":
false_positive = request.POST.get('false')
status = request.POST.get('status')
vuln_id = request.POST.get('vuln_id')
scan_id = request.POST.get('scan_id')
vuln_name = request.POST.get('vuln_name')
gitlabcontainerscan_scan_results_db.objects.filter(
username=username, vuln_id=vuln_id,
scan_id=scan_id).update(false_positive=false_positive,
vuln_status=status)
if false_positive == 'Yes':
vuln_info = gitlabcontainerscan_scan_results_db.objects.filter(
username=username, scan_id=scan_id, vuln_id=vuln_id)
for vi in vuln_info:
Name = vi.message
Severity = vi.Severity
dup_data = Severity + Name
false_positive_hash = hashlib.sha256(
dup_data.encode('utf-8')).hexdigest()
gitlabcontainerscan_scan_results_db.objects.filter(
username=username, vuln_id=vuln_id,
scan_id=scan_id).update(
false_positive=false_positive,
vuln_status='Closed',
false_positive_hash=false_positive_hash)
all_gitlabcontainerscan_data = gitlabcontainerscan_scan_results_db.objects.filter(
username=username,
scan_id=scan_id,
false_positive='No',
vuln_status='Open')
total_vul = len(all_gitlabcontainerscan_data)
total_high = len(
all_gitlabcontainerscan_data.filter(Severity='High'))
total_medium = len(
all_gitlabcontainerscan_data.filter(Severity='Medium'))
total_low = len(
all_gitlabcontainerscan_data.filter(Severity='Low'))
total_duplicate = len(
all_gitlabcontainerscan_data.filter(vuln_duplicate='Yes'))
gitlabcontainerscan_scan_db.objects.filter(
username=username,
scan_id=scan_id).update(total_vul=total_vul,
high_vul=total_high,
medium_vul=total_medium,
low_vul=total_low)
return HttpResponseRedirect(
reverse('gitlabcontainerscan:gitlabcontainerscan_vuln_data') +
'?scan_id=%s&test_name=%s' % (scan_id, vuln_name))
gitlabcontainerscan_vuln_data = gitlabcontainerscan_scan_results_db.objects.filter(
username=username, scan_id=scan_id, message=test_name)
return render(
request, 'gitlabcontainerscan/gitlabcontainerscan_vuln_data.html', {
'gitlabcontainerscan_vuln_data': gitlabcontainerscan_vuln_data,
'jira_url': jira_url
})
def unliked(request, pk):
post = Posts.objects.get(pk=pk)
already_liked = Like.objects.filter(post=post, user=request.user)
already_liked.delete()
return HttpResponseRedirect(reverse('App_Posts:home'))
def update_status(request, oid):
order = Order.objects.filter(id=oid).update(status="confirm")
return HttpResponseRedirect(reverse('show_order'))
def manage_exercises(request, course_prefix, course_suffix, pset_slug):
#Get all necessary information about the problemset
common_page_data = request.common_page_data
data = {'common_page_data': common_page_data}
form = ManageExercisesForm(
initial={'course': common_page_data['course'].id})
pset = ProblemSet.objects.getByCourse(
common_page_data['course']).get(slug=pset_slug)
psetToExs = ProblemSetToExercise.objects.getByProblemset(
pset).select_related('exercise', 'problemSet')
used_exercises = []
problemset_taken = False
if ProblemActivity.objects.filter(
problemset_to_exercise__problemSet=pset.image).exists():
problemset_taken = True
#Get the list of exercises currently in this problem set
for psetToEx in psetToExs:
used_exercises.append(psetToEx.exercise.id)
#Get all the exercises in the course but not in this problem set to list in add from existing
#Q objects allow queryset filters to be ORed together
exercises = Exercise.objects.all().filter(
Q(problemSet__course=common_page_data['course'])
| Q(video__course=common_page_data['course'])).exclude(
id__in=used_exercises).distinct()
#Form processing action if form was submitted
if request.method == 'POST':
form = ManageExercisesForm(request.POST, request.FILES)
if form.is_valid():
pset = ProblemSet.objects.get(id=request.POST['pset_id'])
file_content = request.FILES['file']
file_name = file_content.name
exercise = Exercise()
exercise.handle = request.POST[
'course_prefix'] + '--' + request.POST['course_suffix']
exercise.fileName = file_name
exercise.file.save(file_name, file_content)
exercise.save()
index = ProblemSetToExercise.objects.getByProblemset(pset).count()
psetToEx = ProblemSetToExercise(problemSet=pset,
exercise=exercise,
number=index,
is_deleted=0,
mode='draft')
psetToEx.save()
return HttpResponseRedirect(
reverse('problemsets.views.manage_exercises',
args=(
request.POST['course_prefix'],
request.POST['course_suffix'],
pset.slug,
)))
#If form was not submitted then the form should be displayed or if there were errors the page needs to be rendered again
data['form'] = form
data['course_prefix'] = course_prefix
data['course_suffix'] = course_suffix
data['pset'] = pset
data['psetToExs'] = psetToExs
data['problemset_taken'] = problemset_taken
data['exercises'] = exercises
return render_to_response('problemsets/manage_exercises.html',
data,
context_instance=RequestContext(request))
def our_service(request):
all_service = Service_detail.objects.all()
if all_service:
return render(request, 'app/our_service.html', {'all_service': all_service})
else:
return HttpResponseRedirect(reverse('login'))
def logout(request):
response = HttpResponseRedirect('/cmdb/login/')
#清理cookie里保存username
response.delete_cookie('username')
return response
def acc_logout(request):
logout(request)
return HttpResponseRedirect("/kingadmin/login/")
def deletev(request, pk):
delete = Photo.objects.get(id=pk)
delete.delete()
return HttpResponseRedirect('/')
def user_logout(request):
logout(request)
return HttpResponseRedirect('/')
def loginout(request):
'''注销
'''
response = HttpResponseRedirect("/login")
response.delete_cookie('login_user')
return response
def index(req):
if req.path == '/':
return HttpResponseRedirect('/co/')
return render(req, 'cosite/index.html')
def show_followed(request):
resp = HttpResponseRedirect('/')
resp.set_cookie('show_followed', '1', max_age=30 * 24 * 60 * 60)
return resp
def show(request, course_prefix, course_suffix, pset_slug):
common_page_data = request.common_page_data
try:
ps = ProblemSet.objects.getByCourse(
course=common_page_data['course']).get(slug=pset_slug)
except ProblemSet.DoesNotExist:
messages.add_message(
request, messages.ERROR,
'This Problemset is not visible in the student view at this time. Please note that students will not see this message.'
)
return HttpResponseRedirect(
reverse('problemsets.views.listAll',
args=(course_prefix, course_suffix)))
except ProblemSet.MultipleObjectsReturned:
messages.add_message(
request, messages.ERROR,
'We found multiple problem sets with the same slug. Please try to delete one. This most likely happened due to copying content from another course.'
)
return HttpResponseRedirect(
reverse('problemsets.views.listAll',
args=(course_prefix, course_suffix)))
if not common_page_data['is_course_admin']:
visit_log = PageVisitLog(
course=common_page_data['ready_course'],
user=request.user,
page_type='problemset',
object_id=str(ps.id),
)
visit_log.save()
activity_list = []
cursor = connection.cursor()
#Used to test for valid data
cursor.execute(
"SELECT `c2g_problemset_to_exercise`.`problemSet_id`, `c2g_exercises`.`fileName`, c2g_problemset_to_exercise.number, \
min(case when c2g_problem_activity.complete = 1 then c2g_problem_activity.id else null end) as `first_correct_answer`, \
max(c2g_problem_activity.id) as `max_activity_id` \
FROM `c2g_problem_activity` \
LEFT OUTER JOIN `c2g_problemset_to_exercise` ON (`c2g_problem_activity`.`problemset_to_exercise_id` = `c2g_problemset_to_exercise`.`id`) \
INNER JOIN `c2g_problem_sets` ON (`c2g_problemset_to_exercise`.`problemSet_id` = `c2g_problem_sets`.`id`) \
INNER JOIN `c2g_exercises` ON (`c2g_problemset_to_exercise`.`exercise_id` = `c2g_exercises`.`id`) \
WHERE (`c2g_problemset_to_exercise`.`problemSet_id` = %s \
AND `c2g_problem_activity`.`student_id` = %s ) \
GROUP BY `c2g_problemset_to_exercise`.`problemSet_id`, `c2g_exercises`.`fileName`, c2g_problemset_to_exercise.number \
ORDER BY c2g_problemset_to_exercise.number",
[ps.id, request.user.id])
raw_activity_list = []
for row in cursor.fetchall():
problemset_id = row[0]
filename = row[1]
number = row[2]
first_correct_answer = row[3]
max_activity_id = row[4]
raw_activity_item = {
'problemset_id': problemset_id,
'filename': filename,
'number': number,
'first_correct_answer': first_correct_answer,
'max_activity_id': max_activity_id
}
raw_activity_list.append(raw_activity_item)
#Find deleted files
cursor.execute(
"select e.fileName, p2e.problemSet_id, \
count(case when p2e.is_deleted = 0 then 1 else null end) as `num_active` \
from c2g_problemset_to_exercise p2e, c2g_exercises e \
where p2e.exercise_id = e.id \
and p2e.problemSet_id = %s \
and p2e.mode = 'ready' \
group by e.filename, p2e.problemSet_id \
having num_active = 0", [ps.id])
deleted_exercise_list = []
for row in cursor.fetchall():
filename = row[0]
problemset_id = row[1]
filename_item = {'filename': filename, 'problemset_id': problemset_id}
deleted_exercise_list.append(filename_item)
for raw_activity_item in raw_activity_list:
problemset_id = raw_activity_item['problemset_id']
filename = raw_activity_item['filename']
number = raw_activity_item['number']
first_correct_answer = raw_activity_item['first_correct_answer']
max_activity_id = raw_activity_item['max_activity_id']
if not filename_in_deleted_list(filename, problemset_id,
deleted_exercise_list):
if first_correct_answer == None or first_correct_answer == max_activity_id:
activity_item = ProblemActivity.objects.get(id=max_activity_id)
else:
activity_item = ProblemActivity.objects.get(
id=first_correct_answer)
activity_list.append((activity_item, number))
course = common_page_data['course']
contentsection_list = ContentSection.objects.getByCourse(course=course)
video_list = Video.objects.getByCourse(course=course)
pset_list = ProblemSet.objects.getByCourse(course=course)
additional_pages = AdditionalPage.objects.getSectionPagesByCourse(
course=course)
file_list = File.objects.getByCourse(course=course)
full_contentsection_list, full_index_list = get_full_contentsection_list(
course, contentsection_list, video_list, pset_list, additional_pages,
file_list)
if request.user.is_authenticated():
is_logged_in = 1
else:
is_logged_in = 0
return render_to_response('problemsets/problemset.html', {
'common_page_data': common_page_data,
'pset': ps,
'pset_url': ps.path,
'pset_type': ps.assessment_type,
'pset_penalty': ps.resubmission_penalty,
'pset_attempts_allowed': ps.submissions_permitted,
'activity_list': activity_list,
'contentsection_list': full_contentsection_list,
'full_index_list': full_index_list,
'is_logged_in': is_logged_in
},
context_instance=RequestContext(request))
def vacation_delete(request, pk):
instance = get_object_or_404(Vacation, id=pk)
instance.delete()
return HttpResponseRedirect(reverse('billings:vacation'))
def logout(request):
del request.session['IS_LOGIN']
return HttpResponseRedirect('/app01/home/')
def logout(request):
auth.logout(request)
return HttpResponseRedirect('/')
def logoutUser(request):
response = HttpResponseRedirect(reverse('displayCells'))
response.delete_cookie("auth")
return response
def delete_notification(request, id):
notification_to_delete = TalkAbout.objects.get(id=id)
if request.method == 'DELETE':
notification_to_delete.delete()
return HttpResponseRedirect(reverse('index'))
def view_common(url, request, tag=None, username=None, id=None):
post_form = AddPostForm(request.POST or None, instance=request.user)
comment_form = AddCommentForm(request.POST or None, instance=request.user)
if request.method == 'POST':
# FORMULARZ DODAWANIA POSTU
if post_form.is_valid():
post_form.save()
# FORMULARZ DODAWANIA KOMENTARZA
if comment_form.is_valid():
comment_form.save()
if request.user.is_authenticated:
# user = CustomUser.objects.get(username=request.user)
user = CustomUser.get_user(request.user)
posts = Post.get_posts_except_blocked(user).order_by('-pub_date')
comments = Comment.objects.all().order_by('-pub_date')
else:
posts = Post.objects.all().order_by('-pub_date')
comments = Comment.objects.all().order_by('-pub_date')
parameters = {
'posts': posts,
'comments': comments,
'post_form': post_form,
'comment_form': comment_form
}
if tag:
posts_on_tag = get_posts_on_specific_tag(tag, posts)
parameters.update({'actual_tag': tag, 'posts': posts_on_tag})
if username:
try:
user = CustomUser.get_user(username=username)
filtered_posts = Post.get_user_posts(user)
user_comments_count = Comment.get_user_comment_count(user)
values_to_update = {
'user_data': user,
'user_comments_count': user_comments_count,
'posts': filtered_posts
}
parameters.update(values_to_update)
except ObjectDoesNotExist:
messages.add_message(request, messages.ERROR,
'User does not exist!')
return HttpResponseRedirect(reverse('index'))
if id:
try:
specific_post = Post.get_specific_post(id)
comments_to_post = Comment.get_comments_to_post(specific_post)
parameters.update({
'post': specific_post,
'comments': comments_to_post
})
except ObjectDoesNotExist:
messages.add_message(request, messages.ERROR,
'Post does not exist!')
return HttpResponseRedirect(reverse('index'))
return render(request, url, parameters)
def SearchHandler(request):
key = request.GET.get("key", "") ##获取输入参数key对应的值，默认为空
if key == "":
return HttpResponseRedirect("/art/index")
else:
page = request.GET.get("page", 1)
page = int(page)
# 查询数据，或操作
art_sets = Art.objects.filter(Q(a_title__contains=str(key))
| Q(a_content__contains=str(key))
| Q(a_info__contains=str(key))).distinct()
# 查询数据，与操作
# mdict = {
# 'a_title':str(key),
# 'a_content':str(key)
# }
# Art.objects.filter(mdict)
total = art_sets.count()
shownum = 10
import math
pagenum = int(math.ceil(total / shownum))
if page < 1:
return HttpResponseRedirect(request.path + "?page=%d&key=%s" % (1, key))
if (total > 0) and (page > pagenum):
return HttpResponseRedirect(request.path + "?page=%d&key=%s" % (pagenum, key))
if total == 0:
context = dict(
pagenum=1,
total=0,
prev=1,
next=1,
pagerange=range(1, 2),
data=[],
url=request.path,
key=key,
page=1
)
return render(request, "search_handler.html", context=context)
offset = (page - 1) * shownum
data = art_sets[offset:(shownum + offset)]
btnnum = 5
if btnnum > pagenum:
firstpage = 1
lastpage = pagenum
else:
if page == 1:
firstpage = 1
lastpage = btnnum
else:
firstpage = page - 2
lastpage = page + btnnum - 3
if firstpage < 1:
firstpage = 1
if lastpage > pagenum:
lastpage = pagenum
prev = page - 1
next = page + 1
if prev < 1:
prev = 1
if next > pagenum:
next = pagenum
context = dict(
pagenum=pagenum,
total=total,
prev=prev,
next=next,
pagerange=range(firstpage, lastpage + 1),
data=data,
url=request.path,
key=key,
page=page
)
return render(request, "search_handler.html", context=context)
def delete_view(request,id):
d=Vehicle.objects.get(pk=id)
d.delete()
return HttpResponseRedirect('/display/')
def test(request):
ticket.check_ticket(check_num=barrel.barrel_other)
barrel.get_barrel()
return HttpResponseRedirect('/minigame/lotogame')
