def register_index(request):
if request.method == 'GET':
return render(request, 'userRegistration.html')
else:
uaccount = request.POST.get('uaccount', '')
upwd = request.POST.get('upwd', '')
uphone = request.POST.get('uphone', '')
uemail = request.POST.get('uemail', '')
uphone = int(uphone)
try:
User.objects.get(uaccount=uaccount,
upwd=upwd,
uemail=uemail,
uphone=uphone)
except User.DoesNotExist:
User.objects.create(uaccount=uaccount,
upwd=upwd,
uemail=uemail,
uphone=uphone)
response = HttpResponse('<script>alter(注册成功！！！)</script>')
response.status_code = 302
response.setdefault('Location', '/stu/login/')
return response
response = HttpResponse('<script>alter(注册失败！！！)</script>')
response.status_code = 302
response.setdefault('Location', '/stu/register/')
return response
def login_view(request):
if request.method == 'GET':
if request.COOKIES.has_key('loginUser'):
loginUser = request.COOKIES.get('loginUser', '').split(',')
name = loginUser[0]
pwd = loginUser[1]
return render(request, 'login.html', {'name': name, 'pwd': pwd})
return render(request, 'login.html')
else:
name = request.POST.get('name', '')
pwd = request.POST.get('pwd', '')
flag = request.POST.get('flag', '')
response = HttpResponse()
if name == 'zhangsan' and pwd == '123':
response.status_code = 302
response.setdefault('Location', '/')
if flag == '1':
response.set_cookie('loginUser',
name + ',' + pwd,
max_age=3 * 24 * 60 * 60,
path='/login/')
return response
else:
response.delete_cookie('loginUser', path='/login/')
return response
else:
response.delete_cookie('loginUser', path='/login/')
response.status_code = 302
response.setdefault('Location', '/login/')
return response
def append_response_after(response: HttpResponse, item: str) -> str:
response.setdefault("x-after", "")
items: List[str] = response["x-after"].split()
items.append(item)
items_str = " ".join(items)
response["x-after"] = items_str
return items_str
def login_view(request):
if request.method == 'GET':
# 2.判断客户端是否存在login对应的cookie信息
if request.COOKIES.has_key('login'):
# 3.获取login对应的cookie信息，login对应的value为uname,pwd
login = request.COOKIES.get('login', '').split(',')
# -------------------------------------------------> 解决中文编码问题3
print('我是login：', login)
uname = json.loads(login[0])
pwd = login[1]
return render(request, 'login.html', {'uname': uname, 'pwd': pwd})
return render(request, 'login.html')
else:
# 接收请求参数
uname = request.POST.get('uname', '')
pwd = request.POST.get('pwd', '')
if uname and pwd:
# 查询数据库，并判断在数据库中是否只有一天匹配的信息
c = Employee.objects.filter(ename=uname, epwd=pwd).count()
if c == 1:
# --------------------------------------------------------------------------------------------------------
response = HttpResponse('登录成功')
response.setdefault('Location', '/stu/mybase/')
response.status_code = 302
response.set_cookie('login',
json.dumps(uname) + ',' + pwd,
path='/stu/login/',
max_age=24 * 60 * 60 * 3)
# -------------------------------------------------------------------------------------------------------
return response
else:
# return HttpResponse('登陆失败')
return redirect('/stu/login/')
return render(request, 'login.html')
def common(self, request, mock_path):
mock = get_object_or_404(Mock, mock_path=mock_path, is_active=True)
custom_headers = ResponseHeader.objects.filter(mock=mock,
is_standard=False)
standard_headers = ResponseHeader.objects.filter(mock=mock,
is_standard=True)
content = replace_templates(request=request,
string=mock.response_body,
seq=mock.call_no)
response = HttpResponse(content=content,
status=mock.status.status_code)
for header in custom_headers:
value = replace_templates(request=request,
string=header.value,
seq=mock.call_no)
response.setdefault(header.tag, value)
for header in standard_headers:
value = replace_templates(request=request,
string=header.value,
seq=mock.call_no)
response[header.tag] = value
mock.call_no += 1
mock.save()
req = Request(mock=mock,
method=Method.objects.get(method=request.method),
host=request.get_host(),
port=request.get_port(),
path=request.get_full_path(),
scheme=request.scheme,
body=request.body.decode('utf-8'),
req_no=mock.call_no)
req.save()
for key in request.headers.keys():
header = RequestHeader(request=req,
tag=key,
value=request.headers.get(key))
header.save()
if request.method == 'GET':
for param_tag in request.GET.keys():
param = Parameter(request=req, tag=param_tag)
param.save()
for param_value in request.GET.getlist(param_tag):
value = ParameterValue(parameter=param, value=param_value)
value.save()
elif request.method == 'POST':
for param_tag in request.POST.keys():
param = Parameter(request=req, tag=param_tag, is_post=True)
param.save()
for param_value in request.POST.getlist(param_tag):
value = ParameterValue(parameter=param, value=param_value)
value.save()
for cookie_tag in request.COOKIES.keys():
cookie = Cookie(request=req,
tag=cookie_tag,
value=request.COOKIES.get(cookie_tag))
cookie.save()
return response
def _post(url, body, headers):
"""
Send a post request to DataCite.
Args:
url (str): The URL to call
body (str): The data
headers (dict): A dictionary of headers to use
Return:
a HTTPResponse
"""
_set_timeout()
opener = get_opener()
auth_string = (base64.encodestring(DATACITE_USER_NAME + ':'
+ DATACITE_PASSWORD)).rstrip()
headers.update({'Authorization':'Basic ' + auth_string})
# If the request body is a string, urllib2 attempts to concatenate the url,
# body and headers. If the url is unicode, the request body can get
# converted unicode. This has resulted in issues where there are characters
# with diacritic marks in the request body. To avoid these issues the url is
# UTF-8 encoded.
url_encode = url.encode('utf-8')
req = urllib2.Request(url_encode, data=body, headers=headers)
try:
response = opener.open(req)
except (urllib2.HTTPError) as ex:
msg = ex.readlines()
LOGGING.warn('HTTPError error getting %s. %s', url, msg)
return get_response(msg, ex.code)
except (socket.timeout, urllib2.URLError) as ex:
LOGGING.warn('Timeout or URLError error getting %s. %s', url, ex.reason)
return get_response(ex.reason, 500)
except (SSLError) as ex:
LOGGING.warn('SSLError error getting %s. %s', url, ex)
return get_response(ex, 500)
except UnicodeDecodeError as ex:
LOGGING.info('UnicodeDecodeError error getting %s. %s', url, ex)
return get_response(ex, 500)
finally:
_close(opener)
if response.headers.has_key('Content-Type'):
ret_response = HttpResponse(content_type=
response.headers.get('Content-Type'))
else:
ret_response = HttpResponse()
ret_response.status_code = response.code
ret_response.reason_phrase = response.msg
# pylint: disable=maybe-no-member
ret_response.writelines(response.readlines())
if response.headers.has_key('location'):
ret_response.setdefault('Location', response.headers.get('location'))
return ret_response
def show_photo(request):
user = request.session.get("LOGIN_LOCAL_FLAG")
current_user_id = user.get("id")
sql = "select photo from t_user_info where user_id =%s"
photo_dict = db.query(sql, params=(current_user_id, ))
photo = photo_dict.get("photo")
response = HttpResponse(photo)
response.setdefault("Content-Disposition", "attachment;filename=a.png")
response["Content-Type"] = "image/jp"
return response
def redirect_befor(request):
"""重定向之前页面"""
# return HttpResponseRedirect('/redirect/redirect_after/') #--->302
# return redirect('/redirect/redirect_after/',permanent=True) #-->301永久重定向
#通过改响应信息
response = HttpResponse()
response.status_code = 302
response.setdefault('location', '/redirect/redirect_after/')
# response['status_code'] =302
# response.__setitem__('location','/redirect/redirect_after/')
return response
def resp_to_json(data: Dict[str, Any], token=None) -> HttpResponse:
if not isinstance(data, dict):
raise TypeError('data must be a dict')
resp = HttpResponse(json.dumps(data), content_type='application/json')
resp['Access-Control-Allow-Headers'] = '*'
resp['Access-Control-Allow-Origin'] = '*'
resp['Access-Control-Allow-Credentials'] = True
resp['Access-Control-Allow-Methods'] = 'POST, GET, OPTIONS'
if token:
resp.setdefault('token', token)
resp['Access-Control-Expose-Headers'] = 'token'
return resp
def handle_readrecord_request(request):
resultCode = '0'
returnXmlData = ''
if request.method == 'GET':
print("readrecord view handle_readrecord_request get!!!!!!")
requestAction = request.META.get('HTTP_ACTION', '')
print('readrord view handle_readrecord_request requestAction= %s' %
requestAction)
if requestAction == 'getRecentList':
resultCode, returnXmlData = recentbookhandle.Hand_Recentbook_Get(
request)
elif requestAction == 'getAllReadBookList':
resultCode, returnXmlData = recentbookhandle.Hand_Allbooklist_Get(
request)
elif requestAction == 'getAnnotationList':
resultCode, returnXmlData = annotationreqhandle.Hand_Annotation_Get(
request)
elif requestAction == 'getReadDateBookList':
resultCode, returnXmlData = readdatareqhandle.Handle_ReadDateList_Get(
request)
elif requestAction == 'getPeriodReadWordTime':
resultCode, returnXmlData = readdatareqhandle.Handle_ReadWordTime_Get(
request)
elif requestAction == 'getBookDataList':
resultCode, returnXmlData = readdatareqhandle.Hand_EveryBookData_Get(
request)
response = HttpResponse()
response.setdefault('result-code', resultCode)
response.content_type = 'application/xml'
response.content = returnXmlData
return response
elif request.method == 'POST':
print("readrord view handle_readrecord_request post!!!!!!")
requestAction = request.META.get('HTTP_ACTION', '')
print('readrord view handle_readrecord_request requestAction= %s' %
requestAction)
if requestAction == 'postReadProgressList':
resultCode = readprogressreqhandle.Handle_Readprogress_Post(
request)
elif requestAction == 'postAnnotationList':
resultCode = annotationreqhandle.Handle_Annotation_Post(request)
elif requestAction == 'postRecentList':
resultCode = recentbookhandle.Handle_Recentbook_Post(request)
response = HttpResponse()
response.setdefault('result-code', resultCode)
return response
def root(self, request):
"""
Main API view, returns a list of all available resources
"""
if request.method == 'OPTIONS':
response = HttpResponse()
response['Allow'] = 'GET, HEAD, OPTIONS'
response['Content-Length'] = 0
return response
elif request.method not in ('GET', 'HEAD'):
return Serializer().serialize(
{
'error': 'Not acceptable',
},
request=request,
status=http_client.METHOD_NOT_ALLOWED,
output_format=request.GET.get('format'),
)
response = {
'__str__': self.name,
'__uri__':
request.build_absolute_uri(reverse('api_%s' % self.name)),
'resources': [],
}
for view in self.views:
response.setdefault('views', []).append({
'__str__':
view['prefix'].strip('^').strip('/'),
'__uri__':
request.build_absolute_uri(''.join(
(response['__uri__'], view['prefix'].strip('^')))),
})
for resource in self.resources:
r = {
'__str__':
resource['model'].__name__.lower(),
'__uri__':
request.build_absolute_uri(''.join(
(response['__uri__'], resource['prefix'].strip('^')))),
}
response['resources'].append(r)
if resource['canonical']:
response[resource['model'].__name__.lower()] = r
return Serializer().serialize(response,
request=request,
output_format=request.GET.get('format'))
def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
# This is the same as the default LocaleMiddleware, minus the
# logic that redirects 404's that lack a prefixed language in
# the path into having a language. See
# https://code.djangoproject.com/ticket/32005
language = translation.get_language()
language_from_path = translation.get_language_from_path(request.path_info)
urlconf = getattr(request, 'urlconf', settings.ROOT_URLCONF)
i18n_patterns_used, _ = is_language_prefix_patterns_used(urlconf)
if not (i18n_patterns_used and language_from_path):
patch_vary_headers(response, ('Accept-Language',))
response.setdefault('Content-Language', language)
return response
def root(self, request):
"""
Main API view, returns a list of all available resources
"""
if request.method == 'OPTIONS':
response = HttpResponse()
response['Allow'] = 'GET, HEAD, OPTIONS'
response['Content-Length'] = 0
return response
elif request.method not in ('GET', 'HEAD'):
return Serializer().serialize(
{
'error': 'Not acceptable',
},
request=request,
status=http_client.METHOD_NOT_ALLOWED,
output_format=request.GET.get('format'),
)
response = {
'__str__': self.name,
'__uri__': request.build_absolute_uri(
reverse('api_%s' % self.name)),
'resources': [],
}
for view in self.views:
response.setdefault('views', []).append({
'__str__': view['prefix'].strip('^').strip('/'),
'__uri__': request.build_absolute_uri(''.join((
response['__uri__'],
view['prefix'].strip('^')))),
})
for resource in self.resources:
r = {
'__str__': resource['model'].__name__.lower(),
'__uri__': request.build_absolute_uri(''.join((
response['__uri__'],
resource['prefix'].strip('^')))),
}
response['resources'].append(r)
if resource['canonical']:
response[resource['model'].__name__.lower()] = r
return Serializer().serialize(
response,
request=request,
output_format=request.GET.get('format'))
def doLogin(request):
if request.method == "GET":
#判断request中是否有名字是"login"的cookie--
if request.COOKIES.has_key('login'):
login = request.COOKIES['login']
login_list = login.split(',')
uname = login_list[0]
upwd = login_list[1]
return render(request, 'login.html', {
'uname': uname,
"upwd": upwd
}) #如果检查到有cookie就回返给页面。ok--
return render(request, 'login.html') #如果没有cookie那么就直接返回页面就行了--
else:
response = HttpResponse()
global userNum
userNum = request.POST.get('userNum')
userPw = request.POST.get('userPw')
flag = request.POST.get('flag')
#需要从数据库获取用户名和密码,注意这里不需要判断非空。-
s_count = Employee_Info.objects.filter(
employee_account=userNum, employee_password=userPw).count()
errori = True
if s_count == 1:
response.content = '登陆成功'
#这里需要给前端页面一个判断如果密码失败就alter--
errori = False
if flag:
response.set_cookie('login',
userNum + ',' + userPw,
max_age=3 * 24 * 60 * 60,
path='/')
else:
#这里判断不勾选记住密码，那么一定要删除cookie--
# response.delete_cookie('login')
response.set_cookie('login', max_age=0, path='/')
response.setdefault('Location', '/login/fist/')
response.status_code = 302
return response
else:
#这里是密码失败返回True给前端页面--
errori = True
response.content = '登陆失败'
#这时候就是登陆失败，登陆失败时候需要删除cookie--
response.delete_cookie('login')
#并且重定向到登陆界面--
response.status_code = 302
response.setdefault('Location', '/login/')
return render(request, 'login.html', {'errori': errori})
def proxy_error(response):
"""
Return a wrapped proxy error
Taking a request.response object as input, return it slightly modified
with an extra header for debugging so that we can see where the request
failed
"""
r = HttpResponse(
response.content,
content_type=response.headers["content-type"],
status=response.status_code,
)
r.setdefault("X-PROMGEN-PROXY", response.url)
return r
def get_or_head(request, course_id, version=None):
course_manager = CourseGetter()
course, code = course_manager.check_item(course_id, 'course', version)
if request.method == 'GET':
course_manager = CourseGetter()
course, code = course_manager.check_item(course_id, 'course', version)
if course is not None:
course = course_manager.get_content_item_delta(content_item=course)
return _create_answer(response=(course, code))
elif request.method == 'HEAD' and code == 200:
response = HttpResponse(status=code)
response.setdefault(key='Last-Modified', value=str(course.updated_at))
return response
return HttpResponse(status=405)
def login(request):
if request.method == 'GET':
return render(request, 'LOGIN_login1.html')
else:
#获取请求参数
uname = request.POST.get('uname', '')
pwd = request.POST.get('pwd', '')
#判断用户名登陆是否成功
if uname == 'zhangsan' and pwd == '123':
#重定向方式1
#return HttpResponseRedirect('https://www.baidu.com')
# 重定向方式2
#return redirect('https://www.taobao.com')
# 重定向方式3
resp = HttpResponse()
resp.status_code = 302
resp.setdefault('Location', 'https://www.jd.com')
return resp
return HttpResponseRedirect('/LOGIN/login/')
def login_view(request):
if request.method == 'GET':
# 判断request中是否存在'login'对应cookie信息
if 'login' in request.COOKIES:
# 'zhangsan,123'
login = request.COOKIES.get('login', '').split(',')
sname = login[0]
spwd = login[1]
return render(request, 'login.html', {
'sname': sname,
'spwd': spwd
})
return render(request, 'login.html')
else:
# 获取请求参数
sname = request.POST.get('sname')
spwd = request.POST.get('spwd')
flag = request.POST.get('flag')
response = HttpResponse()
# 判断是否登录成功
if sname == 'zhangsan' and spwd == '123':
response.content = '登录成功！'
# 判断是否需要记住密码
if flag:
# 将用户名和密码存放至cookie中('zhangsan,123')
response.set_cookie('login',
sname + ',' + spwd,
max_age=3 * 24 * 60 * 60,
path='/student/login/')
else:
# 当不需要记住密码时，需要删除cookie中‘login’对应的数据
response.delete_cookie('login', path='/student/login/')
else:
# 当登录失败时，需要删除cookie中‘login’对应的数据
response.delete_cookie('login', path='/student/login/')
# 重定向
response.status_code = 302
response.setdefault('Location', '/student/login/')
return response
def default_index(request):
response = HttpResponse('this girl seems sad')
print(response.content)
response.write('<br/>')
response.write('<h1>Do not be sad</h1>')
print(response.charset) # utf8
response.status_code = 404
print(response.reason_phrase) # 200
response.status_code = 200
print(response.reason_phrase)
print(response.closed)
response = HttpResponse('国不破，山河犹在',
content_type='text/html',
status=220,
reason='ok',
charset='gb2312')
print(response.status_code)
print(response.reason_phrase)
response['girl_name'] = 'alice'
response.__setitem__('girl_sex', 'girl')
response.__delitem__('girl_sex')
print('response.__getitem__=', response.__getitem__('girl_name'))
if response.has_header("this has header"):
print("this header is not exists")
elif response.has_header('girl_name'):
print("response['girl_name']=", response['girl_name'])
else:
print("no no no no n o")
response.setdefault('girl_sex', 'girl')
response.set_cookie('login_user',
'zkq111',
max_age=20,
expires=timezone.now() + datetime.timedelta(days=1))
response.set_cookie('login_user_2',
'zkq222',
expires=timezone.now() + datetime.timedelta(days=1))
request.session['user_login'] = '******'
print(request.session['user_login'])
print(request.COOKIES.get('sessionid'))
print(request.COOKIES)
return response
def download(request, pk):
sql = "select * from t_resource where id = %s"
res = db.query_one(sql, args=(pk, ))
user_id = db.get_current_user_id(request)
if res.get("user_id") != user_id:
if res.get("score") > 0:
sql = "select sum(score) sum from t_user_score where user_id = %s"
user_score = db.query_one(sql, args=(user_id, ))
sum_score = user_score.get("sum")
if sum_score < res.get("score"):
request.session.setdefault("download_msg", "您的积分不足")
return redirect(to="res:detail", **{"pk": pk})
sql = """
select count(1) count from t_resource_download where user_id = %s
and res_id = %s and download_time >= DATE_SUB(now(),INTERVAL 1 MONTH)
"""
last_month_down_count = db.query_one(sql, args=(user_id,
pk)).get("count")
if last_month_down_count == 0:
sql = "insert into t_user_score(score, remark,create_time,user_id) values (%s,%s,now(),%s)"
db.update(sql,
args=(int(res.get("score")) * -1, "资源下载", user_id))
db.update(sql,
args=(int(res.get("score")), "下载资源",
res.get("user_id")))
sql = "insert into t_resource_download(user_id,res_id,download_time) values (%s,%s,now())"
db.update(sql, args=(user_id, pk))
resource_path = res.get("res_address")
with open(resource_path, "rb") as f_r:
file_bytes = f_r.read()
response = HttpResponse(file_bytes,
content_type=res.get("content_type"))
filename = f"{res.get('res_name')}.{res.get('ext')}"
from django.utils.http import urlquote
filename = urlquote(filename)
response.setdefault("Content-Disposition",
"attachment;filename=" + filename)
return response
def CheckVersion(request):
print("apps update views.py checkversion!!!")
resultCode = '0'
returnData = ''
if request.method == 'GET':
requestAction = request.META.get('HTTP_ACTION', '')
if requestAction == "softwareupgrade":
resultCode,returnData = softwarecheck.checkUpdate(request,softwarepackage)
response = HttpResponse()
response.setdefault('result-code', resultCode)
response.content_type = 'application/json'
response.content = json.dumps(returnData)
return response
def tologin_view(request):
#获取请求参数
uname=request.POST.get('uname','')
pwd=request.POST.get('pwd','')
flag=request.POST.get('flag','')
resp=HttpResponse()
#判断是否登陆成功
if uname=='zhangsan' and pwd=='123':
resp.content=u'登陆成功！'
if flag=='1':
resp.set_signed_cookie('user',uname+','+pwd,max_age=3*24*60*60,path='/test_Cookie/login')
return resp
else:
resp.delete_cookie('user',path='/test_Cookie/login')
return resp
else:
resp.delete_cookie('user', path='/test_Cookie/login')
resp.status_code=302
resp.setdefault('Location','/test_Cookie/login')
return resp
def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
# This is the same as the default LocaleMiddleware, minus the
# logic that redirects 404's that lack a prefixed language in
# the path into having a language. See
# https://code.djangoproject.com/ticket/32005
language = translation.get_language()
language_from_path = translation.get_language_from_path(request.path_info)
urlconf = getattr(request, "urlconf", settings.ROOT_URLCONF)
i18n_patterns_used, _ = is_language_prefix_patterns_used(urlconf)
if not (i18n_patterns_used and language_from_path):
patch_vary_headers(response, ("Accept-Language",))
response.setdefault("Content-Language", language)
# An additional responsibility of our override of this middleware is to save the user's language
# preference in a cookie. That determination is made by code handling the request
# and saved in the _set_language flag so that it can be used here.
if hasattr(request, "_set_language"):
response.set_cookie(settings.LANGUAGE_COOKIE_NAME, request._set_language)
return response
def get_articles_from_search(request, page, hours, days, query):
articles = DataAccessManagement.find_articles_by_keywords_and_time(query, hours, days, page)
resp = HttpResponse(articles)
resp.setdefault("Access-Control-Allow-Origin", "*")
resp.setdefault('Access-Control-Allow-Methods', 'GET, POST')
resp.setdefault("Access-Control-Allow-Headers", "Origin, Content-Type, X-Auth-Token")
return resp
def get_articles_from_category(request, category, page):
articles = DataAccessManagement.get_articles_from_category(category, pageNumber=page)
resp = HttpResponse(articles)
resp.setdefault("Access-Control-Allow-Origin", "*")
resp.setdefault('Access-Control-Allow-Methods', 'GET, POST')
resp.setdefault("Access-Control-Allow-Headers", "Origin, Content-Type, X-Auth-Token")
return resp
def login_view(request):
if request.method == 'GET':
#cookies信息
if request.COOKIES.has_key('loginUser'):
loginUser = request.COOKIES.get('loginUser', '').split(',')
name = loginUser[0]
pwd = loginUser[1]
return render(request, 'login.html', {'name': name, 'pwd': pwd})
#如果请求方式是get就直接显示登录界面
return render(request, 'login.html')
else:
# 1.获取请求参数
name = request.POST.get('name')
PWD = request.POST.get('pwd')
flag = request.POST.get('flag')
response = HttpResponse()
if Admin.objects.filter(admin_name=name, admin_password=PWD):
request.session['admin_name'] = name
response.status_code = 302
response.setdefault('Location', '/')
if flag == '1':
response.set_cookie('loginUser',
name + ',' + PWD,
max_age=3 * 24 * 60 * 60,
path='/login/')
return response
else:
response.delete_cookie('loginUser', path='/login/')
return response
else:
response.delete_cookie('loginUser', path='/login/')
response.status_code = 302
response.setdefault('Location', '/login/')
return response
def thumbsDown(request, ratingID, nbSentences):
confirmation = DataAccessManagement.addRating(False, ratingID, nbSentences)
resp = HttpResponse(confirmation)
resp.setdefault("Access-Control-Allow-Origin", "*")
resp.setdefault('Access-Control-Allow-Methods', 'GET, POST')
resp.setdefault("Access-Control-Allow-Headers", "Origin, Content-Type, X-Auth-Token")
return resp
def get_response(request):
"""Return information about HttpResponse object."""
a_dict = {}
m_dict = {}
context = {}
response = HttpResponse()
# Attributes:
response.content = "some content"
a_dict["content"] = response.content
a_dict["charset"] = response.charset
a_dict["status_code"] = response.status_code
a_dict["reason_phrese"] = response.reason_phrase
a_dict["streaming"] = response.streaming
a_dict["closed"] = response.closed
# Methods:
m_dict["__setitem__(header, value)"] = response.__setitem__("test", "Test")
m_dict["__getitem__(header)"] = response.__getitem__("test")
m_dict["__delitem__(header)"] = response.__delitem__("test")
m_dict["has_header(header)"] = response.has_header("test")
m_dict["setdefault(headre, value)"] = response.setdefault("t", "test")
m_dict["set_cookie(key, value='', max_age=None,\
expres=None, path='/', domain=None,\
secure=False, httponly=False,\
samesite=None)"] = response.set_cookie("some", "foo")
m_dict["set_signed_cookie(key, value='', max_age=None,\
expres=None, path='/', domain=None,\
secure=False, httponly=False,\
samesite=None)"] = response.set_signed_cookie("foo", "foo")
m_dict["delete_cookie(key, path='/', domain=None)"] =\
response.delete_cookie("foo")
m_dict["close()"] = response.close()
m_dict["write(content)"] = response.write("<p>CONTENT</p>")
m_dict["flush()"] = response.flush()
m_dict["tell()"] = response.tell()
m_dict["getvalue()"] = response.getvalue()
m_dict["readable()"] = response.readable()
m_dict["seekable()"] = response.seekable()
m_dict["writable()"] = response.writable()
m_dict["writelines(lines)"] = response.writelines([" one",
" two", " three"])
m_dict["lines"] = response.getvalue()
context["a_dict"] = a_dict
context["m_dict"] = m_dict
return render(request, "response_object/response.html", context)
def get_article(request, articleID):
article = DataAccessManagement.get_article_by_id(articleID)
resp = HttpResponse(article)
resp.setdefault("Access-Control-Allow-Origin", "*")
resp.setdefault('Access-Control-Allow-Methods', 'GET, POST')
resp.setdefault("Access-Control-Allow-Headers", "Origin, Content-Type, X-Auth-Token")
log.debug(resp)
return resp
def get_all_articles(request, page):
"""
Gets all the articles for all categories
"""
articles = DataAccessManagement.get_articles(page)
resp = HttpResponse(articles)
resp.setdefault("Access-Control-Allow-Origin", "*")
resp.setdefault('Access-Control-Allow-Methods', 'GET, POST')
resp.setdefault("Access-Control-Allow-Headers", "Origin, Content-Type, X-Auth-Token")
return resp
def feed(req, podcast_slug):
pod = get_object_or_404(Podcast, slug=podcast_slug)
if pod.rss_redirect:
return redirect(pod.rss_redirect, permanent=True)
items = []
episodes = pod.get_episodes()
is_demo = UserSettings.get_from_user(pod.owner).plan == plans.PLAN_DEMO
for ep in episodes:
ep_url = _asset(ep.audio_url + '?x-source=rss&x-episode=%s' % str(ep.id))
md_desc = ep.get_html_description(is_demo=is_demo)
explicit_tag = ''
if ep.explicit_override != PodcastEpisode.EXPLICIT_OVERRIDE_CHOICE_NONE:
explicit_tag = '<itunes:explicit>%s</itunes:explicit>' % (
'yes' if ep.explicit_override == PodcastEpisode.EXPLICIT_OVERRIDE_CHOICE_EXPLICIT else 'clean')
items.append('\n'.join([
'<item>',
'<title>%s</title>' % escape(ep.title),
'<description><![CDATA[%s]]></description>' % md_desc,
'<link>%s</link>' % escape(ep_url),
'<guid isPermaLink="false">https://pinecast.com/guid/%s</guid>' % escape(str(ep.id)),
'<pubDate>%s</pubDate>' % formatdate(time.mktime(ep.publish.timetuple())),
explicit_tag,
'<itunes:author>%s</itunes:author>' % escape(pod.author_name),
'<itunes:subtitle>%s</itunes:subtitle>' % escape(ep.subtitle),
'<itunes:image href=%s />' % quoteattr(_asset(ep.image_url)),
'<itunes:duration>%s</itunes:duration>' % escape(ep.formatted_duration()),
'<enclosure url=%s length=%s type=%s />' % (
quoteattr(ep_url), quoteattr(str(ep.audio_size)), quoteattr(ep.audio_type)),
('<dc:copyright>%s</dc:copyright>' % escape(ep.copyright)) if ep.copyright else '',
('<dc:rights>%s</dc:rights>' % escape(ep.license)) if ep.license else '',
'</item>',
]))
categories = sorted([c.category for c in pod.podcastcategory_set.all()], key=lambda c: len(c))
category_map = {}
for cat in categories:
spl = cat.split('/')
cursor = category_map
for i in spl:
cursor.setdefault(i, {})
cursor = cursor[i]
def render_cat(c):
for k, v in c.items():
if not v:
yield '<itunes:category text=%s />' % quoteattr(k)
else:
yield '<itunes:category text=%s>%s</itunes:category>' % (
quoteattr(k), '\n'.join(render_cat(v)))
content = [
'<?xml version="1.0" encoding="UTF-8"?>',
'<rss xmlns:atom="http://www.w3.org/2005/Atom"',
' xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"',
' xmlns:dc="http://purl.org/dc/elements/1.1/"',
' version="2.0">',
'<channel>',
'<title>%s</title>' % escape(pod.name),
'<link>%s</link>' % escape(pod.homepage),
'<language>%s</language>' % escape(pod.language),
'<copyright>%s</copyright>' % escape(pod.copyright),
'<generator>Pinecast (https://pinecast.com)</generator>',
('<itunes:subtitle>%s</itunes:subtitle>' % escape(pod.subtitle)) if pod.subtitle else '',
'<itunes:author>%s</itunes:author>' % escape(pod.author_name),
'<description><![CDATA[%s]]></description>' % pod.description,
'<itunes:owner>',
'<itunes:name>%s</itunes:name>' % escape(pod.author_name),
'<itunes:email>%s</itunes:email>' % escape(pod.owner.email),
'</itunes:owner>',
'<itunes:explicit>%s</itunes:explicit>' % ('yes' if pod.is_explicit else 'no'),
'<itunes:image href=%s />' % quoteattr(_asset(pod.cover_image)),
'\n'.join(render_cat(category_map)),
'\n'.join(items),
'</channel>',
'</rss>',
]
if UserSettings.get_from_user(pod.owner).plan == plans.PLAN_DEMO:
if len(episodes) > 10:
content.append('<!-- This feed is truncated because the owner is not a paid customer. -->')
else:
content.append('<!-- This feed will be truncated at 10 items because the owner is not a paid customer. -->')
if not analyze.is_bot(req):
browser, device, os = analyze.get_device_type(req)
analytics_log.write('subscribe', {
'id': analyze.get_request_hash(req),
'podcast': unicode(pod.id),
'profile': {
'ip': analyze.get_request_ip(req),
'ua': req.META.get('HTTP_USER_AGENT'),
'browser': browser,
'device': device,
'os': os,
},
}, req=req)
resp = HttpResponse('\n'.join(c for c in content if c), content_type='application/rss+xml')
resp.setdefault('Cache-Control', 'public, max-age=120')
return resp
def _post(url, body, headers, method="POST"):
"""
Send a post request to DataCite.
Args:
url (str): The URL to call
body (str): The data
headers (dict): A dictionary of headers to use
Return:
a HTTPResponse
"""
_set_timeout()
opener = get_opener()
auth_string = ((base64.encodebytes(
(DATACITE_USER_NAME + ":" +
DATACITE_PASSWORD).encode())).decode("utf-8").rstrip())
headers.update({"Authorization": "Basic " + auth_string})
# If the request body is a string, urllib2 attempts to concatenate the url,
# body and headers. If the url is unicode, the request body can get
# converted unicode. This has resulted in issues where there are characters
# with diacritic marks in the request body. To avoid these issues the url is
# UTF-8 encoded.
url_encode = url.encode("utf-8").decode()
req = urllib.request.Request(url_encode,
data=body,
headers=headers,
method=method)
try:
response = opener.open(req)
except urllib.error.HTTPError as ex:
msg = ex.readlines()
LOGGING.warning("HTTPError error getting %s. %s", url, msg)
return get_response(msg, ex.code)
except (socket.timeout, urllib.error.URLError) as ex:
LOGGING.warning("Timeout or URLError error getting %s. %s", url,
ex.reason)
return get_response(ex.reason, 500)
except SSLError as ex:
LOGGING.warning("SSLError error getting %s. %s", url, ex)
return get_response(ex, 500)
except UnicodeDecodeError as ex:
LOGGING.info("UnicodeDecodeError error getting %s. %s", url, ex)
return get_response(ex, 500)
finally:
_close(opener)
if "Content-Type" in response.headers:
ret_response = HttpResponse(
content_type=response.headers.get("Content-Type"))
else:
ret_response = HttpResponse()
ret_response.status_code = response.code
ret_response.reason_phrase = response.msg
# pylint: disable=maybe-no-member
ret_response.writelines(response.readlines())
if "location" in response.headers:
ret_response.setdefault("Location", response.headers.get("location"))
return ret_response
def feed(req, podcast_slug):
pod = get_object_or_404(Podcast, slug=podcast_slug)
items = []
episodes = pod.get_episodes()
is_demo = UserSettings.get_from_user(pod.owner).plan == plans.PLAN_DEMO
channel_explicit_tag = '<itunes:explicit>%s</itunes:explicit>' % ('yes' if pod.is_explicit else 'no')
for ep in episodes:
ep_url = _asset(ep.audio_url + '?x-source=rss&x-episode=%s' % str(ep.id))
md_desc = ep.get_html_description(is_demo=is_demo)
explicit_tag = ''
if ep.explicit_override != PodcastEpisode.EXPLICIT_OVERRIDE_CHOICE_NONE:
explicit_tag = '<itunes:explicit>%s</itunes:explicit>' % (
'yes' if ep.explicit_override == PodcastEpisode.EXPLICIT_OVERRIDE_CHOICE_EXPLICIT else 'clean')
else:
explicit_tag = channel_explicit_tag
items.append('\n'.join([
'<item>',
'<title>%s</title>' % escape(ep.title),
'<description><![CDATA[%s]]></description>' % md_desc,
'<link>%s</link>' % escape(ep_url),
'<guid isPermaLink="false">https://pinecast.com/guid/%s</guid>' % escape(str(ep.id)),
'<pubDate>%s</pubDate>' % formatdate(time.mktime(ep.publish.timetuple())),
explicit_tag,
'<itunes:author>%s</itunes:author>' % escape(pod.author_name),
'<itunes:subtitle>%s</itunes:subtitle>' % escape(ep.subtitle),
'<itunes:image href=%s />' % quoteattr(_asset(ep.image_url)),
'<itunes:duration>%s</itunes:duration>' % escape(ep.formatted_duration()),
'<enclosure url=%s length=%s type=%s />' % (
quoteattr(ep_url), quoteattr(str(ep.audio_size)), quoteattr(ep.audio_type)),
('<dc:copyright>%s</dc:copyright>' % escape(ep.copyright)) if ep.copyright else '',
('<dc:rights>%s</dc:rights>' % escape(ep.license)) if ep.license else '',
'</item>',
]))
categories = sorted([c.category for c in pod.podcastcategory_set.all()], key=lambda c: len(c))
category_map = {}
for cat in categories:
spl = cat.split('/')
cursor = category_map
for i in spl:
cursor.setdefault(i, {})
cursor = cursor[i]
def render_cat(c):
for k, v in c.items():
if not v:
yield '<itunes:category text=%s />' % quoteattr(k)
else:
yield '<itunes:category text=%s>%s</itunes:category>' % (
quoteattr(k), '\n'.join(render_cat(v)))
if pod.rss_redirect:
canonical_url = pod.rss_redirect
else:
canonical_url = 'https://pinecast.com/feed/%s' % escape(pod.slug)
content = [
'<?xml version="1.0" encoding="UTF-8"?>',
'<rss xmlns:atom="http://www.w3.org/2005/Atom"',
' xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd"',
' xmlns:dc="http://purl.org/dc/elements/1.1/"',
' version="2.0">',
'<channel>',
'<title>%s</title>' % escape(pod.name),
'<link>%s</link>' % escape(pod.homepage),
'<atom:link href="%s" rel="self" type="application/rss+xml" />' % canonical_url,
'<language>%s</language>' % escape(pod.language),
'<copyright>%s</copyright>' % escape(pod.copyright),
'<generator>Pinecast (https://pinecast.com)</generator>',
('<itunes:new-feed-url>%s</itunes:new-feed-url>' % escape(canonical_url) if pod.rss_redirect else ''),
('<itunes:subtitle>%s</itunes:subtitle>' % escape(pod.subtitle)) if pod.subtitle else '',
'<itunes:author>%s</itunes:author>' % escape(pod.author_name),
'<description><![CDATA[%s]]></description>' % pod.description,
'<itunes:owner>',
'<itunes:name>%s</itunes:name>' % escape(pod.author_name),
'<itunes:email>%s</itunes:email>' % escape(pod.owner.email),
'</itunes:owner>',
channel_explicit_tag,
'<itunes:image href=%s />' % quoteattr(_asset(pod.cover_image)),
'<image>',
'<title>%s</title>' % escape(pod.name),
'<link>%s</link>' % escape(pod.homepage),
'<url>%s</url>' % escape(_asset(pod.cover_image)),
'</image>',
'\n'.join(render_cat(category_map)),
'\n'.join(items),
'</channel>',
'</rss>',
]
if UserSettings.get_from_user(pod.owner).plan == plans.PLAN_DEMO:
if len(episodes) > 10:
content.append('<!-- This feed is truncated because the owner is not a paid customer. -->')
else:
content.append('<!-- This feed will be truncated at 10 items because the owner is not a paid customer. -->')
# Write the log of this to the analytics back-end(s)
analytics_log.write_subscription(req, pod)
resp = HttpResponse(
'\n'.join(c for c in content if c),
content_type='application/rss+xml',
status=200 if not pod.rss_redirect else 301)
if pod.rss_redirect:
resp.setdefault('Location', pod.rss_redirect)
resp.setdefault('Cache-Control', 'public, max-age=120')
resp.setdefault('Access-Control-Allow-Origin', '*')
resp.setdefault('Access-Control-Request-Method', 'GET')
return resp
from django.shortcuts import render
from django.http import HttpResponse, HttpResponseNotFound
from .models import BCUser
from django.core import serializers
import json
json_response = HttpResponse.setdefault('content_type', 'application/json')
def required_fields(func):
def required_fields_dec(required_list):
for key in request.POST:
if key not in required_fields:
response = {
'error': {
'code': 500,
'message': "Missing field required"
}
}
return HttpResponse(serializers.serializers('json'), [response]))
return required_fields_dec
@require_POST
@required_fields(['first_name', 'last_name', 'email', 'password'])
def register(request):
required_fields = set()
u = BCUser()
u.update_fields(request.POST).save()
response = {
'user_id': u.pk
