def test_newlines_in_headers(self):
# Bug #10188: Do not allow newlines in headers (CR or LF)
r = HttpResponse()
with self.assertRaises(BadHeaderError):
r.__setitem__('test\rstr', 'test')
with self.assertRaises(BadHeaderError):
r.__setitem__('test\nstr', 'test')
def get_esms(request):
print("at get_esms view: get esms")
if request.method != 'GET':
pass
# get esms
esms = ESM.objects.all()
esms_array = []
for esm in esms:
esms_array.append(model_to_dict(esm))
# esms = {}
# for esm in list(all_esms):
# esms[esm.get('id')] = esm
content = {'data': {'esms': esms_array}}
response = HttpResponse(json.dumps(content))
response.__setitem__('Content-Type', 'application/json')
response.__setitem__('Access-Control-Expose-Headers', 'xsrf-token')
response.__setitem__('Access-Control-Allow-Origin',
'http://localhost:4200')
response.__setitem__('Access-Control-Allow-Credentials', 'true')
response.__setitem__('Access-Control-Allow-Headers',
'Content-Type, Authorization')
return response
def User_getinfo(request):
# get
# session demanded in header
res = HttpResponse()
res.__setitem__('content-type','application/json')
try:
session = request.META.__getitem__('HTTP_SESSION')
openid = userSessionQuery.sessionToOpenid(session)
except:
res.write({'error': 1000, 'data': {'info': 'Please login'}})
return res
if 'openid' in request.GET:
openid = request.GET['openid']
user = User.objects.filter(openid=openid)
if(len(user)==0):
res.write({'error':1004,'data':{'info':'No user has the openid inputed'}})
else:
user = user[0]
data = {
"name" : user.name,
"schoolid" : user.schoolid,
"telephone" : user.telephone,
"openid" : user.openid,
"dorm" : user.dorm,
"gender" : user.gender,
"unfinishedorders" : user.unfinishedorders,
"infocompleted" : user.infocompleted
}
res.write({"error":0000,"data":data})
return res
def event_json(request):
status, id, cookie = check_login(request, 'http://scheduler.acm.case.edu/scheduler/')
setcookie = False
if status == False:
return redirect_to_cas('http://scheduler.acm.case.edu/scheduler/')
if cookie != "":
setcookie = True
stu = Student.objects.get(case_id=id)
enrolls = Enrollment.objects.filter(student__case_id=id)
response_data = []
for enroll in enrolls:
event = Event.objects.get(id=enroll.event_id)
start = request.GET.get('start', None)
end = request.GET.get('end', None)
start_date = dateutil.parser.parse(start)
end_date = dateutil.parser.parse(end)
date_to_start = event.start_date if event.start_date > start_date.date() else start_date.date()
date_to_end = event.end_date if event.end_date < end_date.date() else end_date.date()
for dt in rrule.rrule(rrule.DAILY, dtstart=date_to_start, until=date_to_end):
event_data = {}
event_data['id'] = enroll.event_id
try:
event_data['title'] = event.meetingtime.meeting_class.dept + ' ' + str(event.meetingtime.meeting_class.class_number)
except Exception:
event_data['title'] = event.customevent.event_name
event_data['allDay'] = False
if "Su" in event.recur_type and dt.weekday() == 6:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
elif "M" in event.recur_type and dt.weekday() == 0:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
elif "Tu" in event.recur_type and dt.weekday() == 1:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
elif "W" in event.recur_type and dt.weekday() == 2:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
elif "Th" in event.recur_type and dt.weekday() == 3:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
elif "F" in event.recur_type and dt.weekday() == 4:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
elif "Sa" in event.recur_type and dt.weekday() == 5:
event_data['start'] = str(dt.date().isoformat()) + 'T' + str(event.start_time.isoformat())
event_data['end'] = str(dt.date().isoformat()) + 'T' + str(event.end_time.isoformat())
else:
continue
response_data.append(event_data)
response = HttpResponse(json.dumps(response_data), content_type="application/json")
if setcookie == True:
response.__setitem__('Set-Cookie', cookie)
return response
def test_newlines_in_headers(self):
# Bug #10188: Do not allow newlines in headers (CR or LF)
r = HttpResponse()
with self.assertRaises(BadHeaderError):
r.__setitem__('test\rstr', 'test')
with self.assertRaises(BadHeaderError):
r.__setitem__('test\nstr', 'test')
def getGroupsInArea(request):
area = request.GET.get("region")
user = UserPhone.objects.get(phone_number=request.GET.get("phoneNumber"))
print user
# This is a public API, so no need for security check.
# authToken = request.GET.get("securityToken")
# if int(user.token) != int(authToken):
# response = HttpResponse()
# response.status_code = 401
# return response
# response = []
allUserGroups = list(
UserinGroup.objects.filter(region=area).filter(user=user).filter(
isOn=True).values("name", "isOn", "region").distinct())
print allUserGroups
for i in UserinGroup.objects.filter(region=area).exclude(user=user).values(
"name", "isOn", "region").distinct():
i["isOn"] = False
allUserGroups.append(i)
t = loader.get_template('backendStuffs/templatForTable.html')
c = RequestContext(request, {"listi": allUserGroups})
theRenderedContents = t.render(c)
myResponse = HttpResponse()
myResponse.__setitem__("Access-Control-Allow-Origin", "*")
myResponse['content_type'] = "application/xhtml+xml"
myResponse.content = theRenderedContents
return myResponse
def addNews(request):
news_id=request.GET.get('news_id')
news_title=urllib.unquote(request.GET.get('news_title'))
news_info=urllib.unquote(request.GET.get('news_info'))
news_img=request.GET.get('news_img')
news_date=request.GET.get('news_date')
news_source=urllib.unquote(request.GET.get('news_source'))
news_url=request.GET.get('news_url')
type_id=request.GET.get('type_id')
session=db.db_createSession()
news = session.query(News).filter(News.news_id==news_id).all()
if len(news)==0 and len(news_id)==8:
newNews=News()
newNews.news_id=news_id
newNews.news_title=news_title
newNews.news_info=news_info
newNews.news_content=news_url
newNews.news_img='{'+news_img+'}'
newNews.news_date=news_date
newNews.news_source=news_source
newNews.news_url=news_url
newNews.news_status=0
newNews.type_id=type_id
session.add(newNews)
session.commit()
session.close()
response=HttpResponse('succeed')
response.__setitem__('Access-Control-Allow-Origin','http://54.223.148.123:8070')
return response
else:
response=HttpResponse('failed')
response.__setitem__('Access-Control-Allow-Origin','http://54.223.148.123:8070')
return response
def openDocument(request, id):
print "Opening document " + id
doc = getHtml(settings.GLOBAL_LOAD.docList.docs[int(id)])
response = HttpResponse(doc, content_type='text/html')
response.__setitem__("Access-Control-Allow-Origin",
"*") #enables CORS (required to use json)
return response
def widget_detail(request, pk):
try:
widget = Widget.objects.get(pk=pk)
except Widget.DoesNotExist:
response = HttpResponse(status=404)
response.__setitem__('Access-Control-Allow-Origin', '*')
return response
if request.method == 'OPTIONS':
response = HttpResponse(status=200)
response.__setitem__('Access-Control-Allow-Origin', '*')
response.__setitem__('Access-Control-Allow-Methods', 'OPTIONS, GET, DELETE')
return response
elif request.method == 'GET':
serializer = WidgetSerializer(widget)
response = JsonResponse(serializer.data)
response.__setitem__('Access-Control-Allow-Origin', '*')
return response
elif request.method == 'DELETE':
widget.delete()
response = HttpResponse(status=204)
response.__setitem__('Access-Control-Allow-Origin', '*')
return response
def APIResponseOK(content=None, pg=1, total=None):
'''
An API friendly wrapper for a 200 HttpResponse object, used to return
a collection of objects in json format
Arguments:
content
A collection of objects. Must be json serializable.
pg
(optional) the page, if this is part of a paginated collection
total
(optional) total number of objects, if this is part of a paginated
collection
'''
content = simplejson.dumps(content, ensure_ascii=False)
resp = HttpResponse(status=200,
mimetype='application/json; charset=utf-8',
content=content)
if total:
resp.__setitem__('X-Object-Total', str(total))
resp.__setitem__('X-Page-Number', str(pg))
return resp
def deleteCover(request):
news_id=request.GET.get('news_id')
print 'news_id:'+news_id
# 创建Session:
session=db.db_createSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
img = session.query(Image).filter(Image.news_id==news_id).one()
if img:
rm='/usr/workspace/news/static/images/'+img.news_cover
os.remove(rm)
imgs = img.news_img[1:-1].split(',')
imgs.remove(img.news_cover)
img.news_img=imgs
img.news_cover=''
session.add(img)
session.commit()
session.close()
resJSON='{"result":"succeed"}'
else:
resJSON='{"result":"failed"}'
response = HttpResponse(json.dumps(resJSON))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def setCover(request):
print 'a'
news_id=request.GET.get('news_id')
image_id=request.GET.get('image_id')
news_img=request.GET.get('news_img')
print 'news_id:'+news_id
print 'image_id:'+image_id
print 'news_img:'+news_img
file_name=news_id+'_'+image_id+'.'+news_img.split('.').pop().lower()
# file_name=news_id+'_'+image_id+'.jpg'
print 'here:'+file_name
# 创建Session:
session=db.db_createSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
img = session.query(Image).filter(Image.news_id==news_id).all()
if img:
img[0].news_cover=file_name
session.add(img[0])
session.commit()
session.close()
else:
img=Image()
img.news_id=news_id
img.news_cover=file_name
session.add(img)
session.commit()
session.close()
response = HttpResponse(file_name)
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def search_common(request):
start_time = time.time()
# Parse HTTP Request
try:
keyword = request.GET["keyword"]
condition = {}
for k in [
"region", "court_level", "year", "judicial_procedure",
"document_type", "cause_of_action"
]:
if k in request.GET:
tmp = request.GET[k]
if k == "cause_of_action":
tmp = list(tmp.split(','))
condition[k] = tmp
page = request.GET["page"] if "page" in request.GET else 1
page = int(page)
info = {}
result = backend.search_common(keyword,
condition,
ret_info=info,
page=page)
obj = {
"info": info,
"result": result,
"time_cost": time.time() - start_time
}
except:
return render(request, "template.html", {"string": "Invalid Request."})
# return render(request,"template.html",{"string":json.dumps(obj,ensure_ascii=False,indent=2)})
resp = HttpResponse(json.dumps(obj, ensure_ascii=False, indent=2))
resp.__setitem__("Access-Control-Allow-Origin", "*")
return resp
def get_result_data_file(request):
target = get_object_or_404(Result, pk=request.GET['id'])
task = get_object_or_404(Task, pk=request.GET['id'])
if target.application.user != request.user:
return render(request, '404.html')
id = int(request.GET['id'])
type = request.GET['type']
prefix = get_result_data_dir(id)
if type == 'sample':
response = HttpResponse(FileWrapper(file(prefix + '_' + type)),
content_type='text/plain')
response.__setitem__(
'Content-Disposition',
'attachment; filename=result_' + str(id) + '.sample')
return response
elif type == 'raw':
response = HttpResponse(FileWrapper(file(prefix + '_' + type)),
content_type='text/plain')
response['Content-Disposition'] = 'attachment; filename=result_' + str(
id) + '.raw'
return response
elif type == 'new_conf':
response = HttpResponse(FileWrapper(file(prefix + '_' + type)),
content_type='text/plain')
response['Content-Disposition'] = 'attachment; filename=result_' + str(
id) + '_new_conf'
return response
def relayMessageToGroup(request):
print request.POST.get("From")[2:]
thing = request.POST.get("From")[2:]
user = UserPhone.objects.get(phone_number=thing)
print ""
print "Hey"
toNumber = request.POST.get("To")
post = request.POST.get("Body")
groups = UserinGroup.objects.filter(region=user.region).filter(user=user)
for group in groups:
groupList = [
x.user for x in UserinGroup.objects.filter(
region=group.region).filter(name=group.name).exclude(user=user)
]
ACCOUNT_SID = "ACf3f0805e01bc0a3db41e7aae79bc96d5"
AUTH_TOKEN = "acf544c7ffb70d7b888eabc81d75698a"
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
for i in groupList:
client.messages.create(
to=i.phone_number,
from_=toNumber,
body=post,
)
response = HttpResponse()
response.status_code = 200
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def get_resource_response(gadgetlist, format, items, user):
if format == 'json' or format == 'default':
gadgetresource = {}
resource_data = serializers.serialize('python',
gadgetlist,
ensure_ascii=False)
resource_data_list = [
get_gadgetresource_data(d, user) for d in resource_data
]
gadgetresource['resourceList'] = resource_data_list
response = HttpResponse(json_encode(gadgetresource),
mimetype='application/json; charset=UTF-8')
response.__setitem__('items', items)
return response
elif format == 'xml':
response = get_xml_description(gadgetlist, user)
response = HttpResponse(response, mimetype='text/xml; charset=UTF-8')
response.__setitem__('items', items)
return response
else:
return HttpResponseServerError(
get_xml_error(
_("Invalid format. Format must be either xml or json")),
mimetype='application/xml; charset=UTF-8')
def headinfo(request):
type_id = request.GET.get("type_id")
session = db.db_createSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
newses = session.query(News).filter(News.news_status == "3").all()
results = []
for news in newses:
# 打印类型和对象的name属性:
if type_id in news.type_id.split(","):
image = session.query(Image).filter(Image.news_id == news.news_id).one()
result = [
{
"news_id": news.news_id,
"news_title": news.news_title,
"news_info": news.news_info,
"news_content": news.news_content,
"news_img": "http://54.223.148.123:8090/static/images/" + image.news_cover,
"type_id": type_id,
}
]
print result
results += result
# 关闭Session:
session.close()
response = HttpResponse('{"news":' + json.dumps(results) + "}", content_type="application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def export_as_xml(modeladmin, request, queryset):
response = HttpResponse(mimetype="text/javascript")
serializers.serialize("xml", queryset, stream=response)
response.__setitem__("Content-type", "application/octet-stream")
response.__setitem__('Content-Disposition', 'attachment; filename="data.xml"')
# writeTofile("xml.txt", response._get_content())
return response
def APIResponseOK(content=None, pg = 1, total = None):
'''
An API friendly wrapper for a 200 HttpResponse object, used to return
a collection of objects in json format
Arguments:
content
A collection of objects. Must be json serializable.
pg
(optional) the page, if this is part of a paginated collection
total
(optional) total number of objects, if this is part of a paginated
collection
'''
content = simplejson.dumps(content, ensure_ascii=False)
resp = HttpResponse(status=200, mimetype='application/json; charset=utf-8', content=content)
if total:
resp.__setitem__('X-Object-Total', str(total))
resp.__setitem__('X-Page-Number', str(pg))
return resp
def room(request, room_name):
try:
room = ChatRoom.objects.get(topic=room_name)
if room.private:
return redirect("/chat/")
messages = [
m.text for m in room.message_set.all().order_by('date', 'text')
]
except ChatRoom.DoesNotExist:
room = ChatRoom.create(room_name)
room.save()
messages = []
try:
alias = request.session['alias']
except:
alias = "anon"
# return render(request, 'chat/room.html', {
# 'alias': alias,
# 'room_name': room_name
# })
print(messages)
response = HttpResponse(
json.dumps({
'alias': alias,
'room_topic': room_name,
'messages': messages
}))
host = socket.gethostbyname(socket.gethostname())
response.__setitem__('host_ip', host)
response['Access-Control-Allow-Origin'] = '*'
return response
def sendSmsVerificationCode(request):
userPhoneNumberToVerify = request.POST.get("userPhoneNumber")
print userPhoneNumberToVerify
# This should be the "master number" for our Twilio account.
fromNumber = "+14012065509"
ACCOUNT_SID = "ACf3f0805e01bc0a3db41e7aae79bc96d5"
AUTH_TOKEN = "acf544c7ffb70d7b888eabc81d75698a"
client = TwilioRestClient(ACCOUNT_SID, AUTH_TOKEN)
verificationCode = "{0:04d}".format(randint(0, 9999))
user = UserPhone.objects.get(phone_number=userPhoneNumberToVerify)
user.verificationNumber = verificationCode
user.save()
client.messages.create(
to=userPhoneNumberToVerify,
from_=fromNumber,
body="Here is your TurnedOn verification code: " + verificationCode,
)
response = HttpResponse()
response.status_code = 200
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def sign_out(request, username, password):
print(username, password)
logout(request) # TODO: ?
response = HttpResponse('')
host = socket.gethostbyname(socket.gethostname())
response.__setitem__('host_ip', host)
response['Access-Control-Allow-Origin'] = '*'
return response
def record_export(request, domain_id):
utils = Utils()
response = HttpResponse()
utils.export_records(record, domain_id, response)
response[
'Content-Disposition'] = 'attachment; filename="%s.csv"' % domain_id
response.__setitem__('content-type', 'text/csv')
return response
def topic_tree_javascript(request):
global TOPIC_TREE_JS
if TOPIC_TREE_JS == '':
TOPIC_TREE_JS = get_topic_tree_js(request.user)
response = HttpResponse(TOPIC_TREE_JS)
response.__setitem__('Content-Type','text/plain')
return response
def jsonToGzip_oil(temp):
tmpstr = str(temp)
by = str.encode(tmpstr)
tempGlobal = gzip.compress(by)
response = HttpResponse(tempGlobal)
response['Content-Type'] = 'application/json'
response.__setitem__('Content-Encoding', "gzip")
return response
def addImg(request):
news_id=request.GET.get('news_id')
image_id=request.GET.get('image_id')
news_img=request.GET.get('news_img')
print 'news_id:'+news_id
print 'image_id:'+image_id
print 'news_img:'+news_img
path=r'/usr/workspace/news/static/images/'
file_name=news_id+'_'+image_id+'.'+news_img.split('.').pop().lower()
# file_name=news_id+'_'+image_id+'.jpg'
print file_name
dest_dir=os.path.join(path,file_name)
url=news_img
try:
urllib.urlretrieve(url,dest_dir)
except:
print '\tError retrieving the URL:',dest_dir
# 创建Session:
session=db.db_createSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
img = session.query(Image).filter(Image.news_id==news_id).all()
if img:
if img[0].news_img:
imgs = img[0].news_img[1:-1].split(',')
else:
imgs =[]
file_name=news_id+'_'+image_id+'.'+news_img.split('.').pop().lower()
# file_name=news_id+'_'+image_id+'.jpg'
# if imgs:
imgs.append(file_name)
img[0].news_img=imgs
# else:
session.add(img[0])
session.commit()
session.close()
# return HttpResponse("192.168.1.104:8080/static/images/"+file_name)
else:
img=Image()
img.image_id=news_id
img.news_img=[file_name]
session.add(img)
session.commit()
session.close()
resJSON='{"newUrl":"http://54.223.148.123:8090/static/images/'+file_name+'","image_id":"'+image_id+'"}'
# response = HttpResponse("http://192.168.1.104:8080/static/images/"+file_name)
response = HttpResponse(json.dumps(resJSON))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def search(request, text):
print "Received search request: " + text
#result = "{\"lol\": \"" + text + "\"}"
#result = '{"id":[147, 19, 28]}'
result = settings.GLOBAL_LOAD.docList.search(text)
result_json = json.dumps(result, default=lambda o: o.__dict__)
response = HttpResponse(result_json, content_type='application/json')
response.__setitem__("Access-Control-Allow-Origin", "*") #enables CORS (required to use json)
return response
def __createHttpResponseJson( results ) :
response = HttpResponse(
mimetype = 'application/json; charset=utf-8',
content_type = 'application/json; charset=utf-8',
)
response.__setitem__( 'Access-Control-Allow-Origin', '*' )
response.content = simplejson.dumps( results, ensure_ascii = False )
return response
def index(request):
query = request.GET.get('query', '')
qa_pair = {}
qa_pair['query'] = query
answer = seq2seq.infer(query)
qa_pair['answer'] = answer
qa_json = json.dumps(qa_pair)
response = HttpResponse(qa_json)
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def detail_common(request):
try:
reference_number = request.GET["rnum"]
obj = backend.get_common_case_by_reference_number(reference_number)
except:
return render(request, "template.html", {"string": "Invalid Request."})
# return render(request,"template.html",{"string":json.dumps(obj,indent=2,ensure_ascii=False)})
resp = HttpResponse(json.dumps(obj, ensure_ascii=False, indent=2))
resp.__setitem__("Access-Control-Allow-Origin", "*")
return resp
def detail_authoritative(request):
try:
unique_id = request.GET["id"]
obj = backend.get_authoritative_case_by_unique_id(unique_id)
except:
return render(request, "template.html", {"string": "Invalid Request."})
# return render(request,"template.html",{"string":json.dumps(obj,indent=2,ensure_ascii=False)})
resp = HttpResponse(json.dumps(obj, ensure_ascii=False, indent=2))
resp.__setitem__("Access-Control-Allow-Origin", "*")
return resp
def captcha(request):
from common.generate_captcha import create_validate_code
code_img = create_validate_code()
request.session["captcha"] = code_img[1]
response = HttpResponse(mimetype="image/gif")
response.__setitem__('Expires', '0')
response.__setitem__('Pragma', 'no-cache')
code_img[0].save(response, "GIF")
return response
def search(request, text):
print "Received search request: " + text
#result = "{\"lol\": \"" + text + "\"}"
#result = '{"id":[147, 19, 28]}'
result = settings.GLOBAL_LOAD.docList.search(text)
result_json = json.dumps(result, default=lambda o: o.__dict__)
response = HttpResponse(result_json, content_type='application/json')
response.__setitem__("Access-Control-Allow-Origin",
"*") #enables CORS (required to use json)
return response
def captcha(request):
from common.generate_captcha import create_validate_code
code_img = create_validate_code()
request.session["captcha"] = code_img[1]
response = HttpResponse(mimetype="image/gif")
response.__setitem__('Expires', '0')
response.__setitem__('Pragma', 'no-cache')
code_img[0].save(response, "GIF")
return response
def post(self,request):
res = HttpResponse()
res.__setitem__('Access-Control-Allow-Origin', '*')
post = request.POST
print(post)
if (not 'openid' in post) or self.infoChange(post['openid'],post)==0:
res.write({'error':1003,'data':{'info':'This openid does not exist'}})
else:
res.write({'error':0,'data':{'info':'Success to change'}})
return res
def myEnvios(request):
body_unicode = request.body.decode('utf-8')
try:
body = json.loads(body_unicode)
except ValueError:
return HttpResponse('No tiene acceso a este recurso')
envios = Envio.objects.filter(usuario_id=body['user_id'])
data = serializers.serialize('json', envios)
response = HttpResponse(data, content_type='application/json')
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def noticiasUsuarios(request):
body_unicode = request.body.decode('utf-8')
try:
body = json.loads(body_unicode)
except ValueError:
return HttpResponse('No tiene acceso a este recurso')
noticias_usuarios = Noticias_usuarios.objects.all()
data = serializers.serialize('json', noticias_usuarios)
response = HttpResponse(data, content_type='application/json')
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def addBlog(request):
print 's'
blog_title = request.POST.get('blog_title')
blog_content = request.POST.get('blog_content')
blog_tel = request.POST.get('blog_tel')
blog_name = request.POST.get('blog_name')
blog_role = request.POST.get('blog_role')
print blog_title,blog_content,blog_tel,blog_name
blog_time=str(datetime.datetime.now())
session = db.db_createSession()
chars=string.ascii_letters+string.digits
ss=''.join([random.choice(chars) for i in range(4)])
print 'a'
blog_id=blog_tel.encode('utf-8')+ss
status=True
print 'b'
while status:
print 'a'
chars=string.ascii_letters+string.digits
ss=''.join([random.choice(chars) for i in range(4)])
blog_id=blog_tel.encode('utf-8')+ss
print 's'
if checkBlog(session,blog_id):
print 'sdfsdfewf---'
status=False
print 'sds'
blog=Blog()
blog.blog_id=blog_id
blog.blog_tel=blog_tel
if blog_name:
blog.blog_name=blog_name
blog.blog_title=blog_title
blog.blog_content=blog_content
blog.blog_role=blog_role
blog.blog_time=blog_time
blog.blog_status='0'
print 's'
f=request.FILES["blog_img"]
# f=request.GET.get('blog_img')
file_name=blog_id+'.jpg'
print 'sd'
with open('/usr/workspace/news/static/images/'+file_name,'wb+') as destination:
# with open('/Users/Csd/PycharmProjects/lokimo/static/images/'+file_name,'wb+') as destination:
for chunk in f.chunks():
destination.write(chunk)
print 'sdfsdf'
session.add(blog)
session.commit()
session.close()
response=HttpResponse("succeed")
response.__setitem__("Access-Control-Allow-Origin","*")
return response
def types(request):
"""
Get all the business types from listings and aggregate listings count.
:param request:
:return:
"""
types_data = TNZListing.objects.values('business_type').annotate(
listings_count=Count('id'))
response = HttpResponse(json.dumps({'data': list(types_data)}))
response.__setitem__('Content-Type', 'application/json')
return response
def displayUser(request):
body_unicode = request.body.decode('utf-8')
try:
body = json.loads(body_unicode)
except ValueError:
return HttpResponse('')
users = Usuario.objects.filter(id=body['usuario_id'])
data = serializers.serialize('json', users)
response = HttpResponse(data, content_type='application/json')
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def sign_in(request, username, password):
user = authenticate(username=username, password=password)
if user is not None:
login(request, user)
response = HttpResponse('')
else:
response = HttpResponse('Authentication error', status=401)
host = socket.gethostbyname(socket.gethostname())
response.__setitem__('host_ip', host)
response['Access-Control-Allow-Origin'] = '*'
return response
def test_headers_type(self):
r = HttpResponse()
# The following tests explicitly test types in addition to values
# because in Python 2 u'foo' == b'foo'.
# ASCII unicode or bytes values are converted to native strings.
r["key"] = "test"
self.assertEqual(r["key"], str("test"))
self.assertIsInstance(r["key"], str)
r["key"] = "test".encode("ascii")
self.assertEqual(r["key"], str("test"))
self.assertIsInstance(r["key"], str)
self.assertIn(b"test", r.serialize_headers())
# Latin-1 unicode or bytes values are also converted to native strings.
r["key"] = "café"
self.assertEqual(r["key"], force_str("café", "latin-1"))
self.assertIsInstance(r["key"], str)
r["key"] = "café".encode("latin-1")
self.assertEqual(r["key"], force_str("café", "latin-1"))
self.assertIsInstance(r["key"], str)
self.assertIn("café".encode("latin-1"), r.serialize_headers())
# Other unicode values are MIME-encoded (there's no way to pass them as bytes).
r["key"] = "†"
self.assertEqual(r["key"], str("=?utf-8?b?4oCg?="))
self.assertIsInstance(r["key"], str)
self.assertIn(b"=?utf-8?b?4oCg?=", r.serialize_headers())
# The response also converts unicode or bytes keys to strings, but requires
# them to contain ASCII
r = HttpResponse()
del r["Content-Type"]
r["foo"] = "bar"
l = list(r.items())
self.assertEqual(len(l), 1)
self.assertEqual(l[0], ("foo", "bar"))
self.assertIsInstance(l[0][0], str)
r = HttpResponse()
del r["Content-Type"]
r[b"foo"] = "bar"
l = list(r.items())
self.assertEqual(len(l), 1)
self.assertEqual(l[0], ("foo", "bar"))
self.assertIsInstance(l[0][0], str)
r = HttpResponse()
with self.assertRaises(UnicodeError):
r.__setitem__("føø", "bar")
with self.assertRaises(UnicodeError):
r.__setitem__("føø".encode("utf-8"), "bar")
def test_headers_type(self):
r = HttpResponse()
# The following tests explicitly test types in addition to values
# because in Python 2 u'foo' == b'foo'.
# ASCII unicode or bytes values are converted to native strings.
r['key'] = 'test'
self.assertEqual(r['key'], str('test'))
self.assertIsInstance(r['key'], str)
r['key'] = 'test'.encode('ascii')
self.assertEqual(r['key'], str('test'))
self.assertIsInstance(r['key'], str)
self.assertIn(b'test', r.serialize_headers())
# Latin-1 unicode or bytes values are also converted to native strings.
r['key'] = 'café'
self.assertEqual(r['key'], force_str('café', 'latin-1'))
self.assertIsInstance(r['key'], str)
r['key'] = 'café'.encode('latin-1')
self.assertEqual(r['key'], force_str('café', 'latin-1'))
self.assertIsInstance(r['key'], str)
self.assertIn('café'.encode('latin-1'), r.serialize_headers())
# Other unicode values are MIME-encoded (there's no way to pass them as bytes).
r['key'] = '†'
self.assertEqual(r['key'], str('=?utf-8?b?4oCg?='))
self.assertIsInstance(r['key'], str)
self.assertIn(b'=?utf-8?b?4oCg?=', r.serialize_headers())
# The response also converts unicode or bytes keys to strings, but requires
# them to contain ASCII
r = HttpResponse()
del r['Content-Type']
r['foo'] = 'bar'
l = list(r.items())
self.assertEqual(len(l), 1)
self.assertEqual(l[0], ('foo', 'bar'))
self.assertIsInstance(l[0][0], str)
r = HttpResponse()
del r['Content-Type']
r[b'foo'] = 'bar'
l = list(r.items())
self.assertEqual(len(l), 1)
self.assertEqual(l[0], ('foo', 'bar'))
self.assertIsInstance(l[0][0], str)
r = HttpResponse()
with self.assertRaises(UnicodeError):
r.__setitem__('føø', 'bar')
with self.assertRaises(UnicodeError):
r.__setitem__('føø'.encode('utf-8'), 'bar')
def authenticateFirst(request):
#accepts post request
#parameters in the header : x : random number
#client requests access to the database for the first time when he has no valid session key.
#session key is a bit string for feige fiat shamir protocol
#This part is for removing the old sessions
sessions = Session.objects.all()
threshold = timedelta(minutes=SESSION_LENGTH)
now = datetime.now(timezone.utc)
for s in sessions:
if now - s.timeStamp > threshold:
s.delete()
json_data = {}
header = request.META
try:
# case server 200.000.02.001
clientIP = request.META['HTTP_X_FORWARDED_FOR']
except:
# case localhost ou 127.0.0.1
clientIP = request.META['REMOTE_ADDR']
try:
Session.objects.get(keyHolderIP=clientIP)
json_data.update({
"authenticationCode": alreadyHaveSessionKey,
"infoA": "you already have a session key"
})
returnStr = json.dumps(json_data)
response = HttpResponse(returnStr, content_type="application/json")
return response
except:
pass
sessionKey = ""
for i in range(SESSION_KEY_LENGTH):
nextBit = randint(0, 1)
sessionKey += str(nextBit)
json_data.update({
"authenticationCode":
gotFirstSessionKey,
"infoA":
"you got your first session key use it to stay authenticated"
})
returnStr = json.dumps(json_data)
session = Session(x=header['HTTP_X'],
sessionKey=sessionKey,
keyHolderIP=clientIP)
session.save()
response = HttpResponse(returnStr, content_type="application/json")
response.__setitem__("sessionKey", sessionKey)
return response
def test_headers_type(self):
r = HttpResponse()
# The following tests explicitly test types in addition to values
# because in Python 2 u'foo' == b'foo'.
# ASCII unicode or bytes values are converted to native strings.
r['key'] = 'test'
self.assertEqual(r['key'], str('test'))
self.assertIsInstance(r['key'], str)
r['key'] = 'test'.encode('ascii')
self.assertEqual(r['key'], str('test'))
self.assertIsInstance(r['key'], str)
self.assertIn(b'test', r.serialize_headers())
# Latin-1 unicode or bytes values are also converted to native strings.
r['key'] = 'café'
self.assertEqual(r['key'], force_str('café', 'latin-1'))
self.assertIsInstance(r['key'], str)
r['key'] = 'café'.encode('latin-1')
self.assertEqual(r['key'], force_str('café', 'latin-1'))
self.assertIsInstance(r['key'], str)
self.assertIn('café'.encode('latin-1'), r.serialize_headers())
# Other unicode values are MIME-encoded (there's no way to pass them as bytes).
r['key'] = '†'
self.assertEqual(r['key'], str('=?utf-8?b?4oCg?='))
self.assertIsInstance(r['key'], str)
self.assertIn(b'=?utf-8?b?4oCg?=', r.serialize_headers())
# The response also converts unicode or bytes keys to strings, but requires
# them to contain ASCII
r = HttpResponse()
del r['Content-Type']
r['foo'] = 'bar'
headers = list(r.items())
self.assertEqual(len(headers), 1)
self.assertEqual(headers[0], ('foo', 'bar'))
self.assertIsInstance(headers[0][0], str)
r = HttpResponse()
del r['Content-Type']
r[b'foo'] = 'bar'
headers = list(r.items())
self.assertEqual(len(headers), 1)
self.assertEqual(headers[0], ('foo', 'bar'))
self.assertIsInstance(headers[0][0], str)
r = HttpResponse()
with self.assertRaises(UnicodeError):
r.__setitem__('føø', 'bar')
with self.assertRaises(UnicodeError):
r.__setitem__('føø'.encode('utf-8'), 'bar')
def inner(request, *args, **kwargs):
result = f(request, *args, **kwargs)
if result is None:
raise Http404
r = HttpResponse(content_type='application/json')
if result:
r.__setitem__("Access-Control-Allow-Origin", "*")
r.write(json.dumps(result))
else:
r.write("{}")
return r
def proxy(request):
print 'In proxy'
url = request.GET['url']
# Get the json data from the api call
api_data = execute_khan_api_method(profile_access_token=request.user.get_profile().access_token, api_method=url)
# Returns a dictionary with keys: 'headers', 'body', and 'status'.
resource = CLIENT.access_api_resource(
url,
access_token(request.session),
method = request.method
)
# put the data into a response for the api explorer,
# or other clients that want to see the text in the HTML
response = HttpResponse(api_data)
# Include the original headers and status as custom response headers. The
# client side will know what to do with these.
response.__setitem__('X-Original-Headers', urllib.quote("".join(resource['headers'])))
response.__setitem__('X-Original-Status',resource['status'])
is_html = has_text_html_header(resource['headers'])
if is_html:
response.__setitem__('Content-Type','text/html')
else:
response.__setitem__('Content-Type','application/json')
return response
def get_resource_response(gadgetlist, format, items, user):
"""Obtains all the information related to a gadget encoded in the properly format (json or xml)."""
if format == 'json' or format == 'default':
gadgetresource = {'resourceList': [get_gadgetresource_data(resource, user) for resource in gadgetlist]}
response = HttpResponse(json_encode(gadgetresource), mimetype='application/json; charset=UTF-8')
response.__setitem__('items', items)
return response
elif format == 'xml':
response = get_xml_description(gadgetlist, user)
response = HttpResponse(response, mimetype='text/xml; charset=UTF-8')
response.__setitem__('items', items)
return response
else:
return HttpResponseServerError(get_xml_error(_("Invalid format. Format must be either xml or json")), mimetype='application/xml; charset=UTF-8')
def get_resource_response(gadgetlist, format, items, user):
if format == 'json' or format=='default':
gadgetresource = {}
resource_data = serializers.serialize('python', gadgetlist, ensure_ascii=False)
resource_data_list = [get_gadgetresource_data(d, user) for d in resource_data]
gadgetresource['resourceList'] = resource_data_list
response = HttpResponse(json_encode(gadgetresource), mimetype='application/json; charset=UTF-8')
response.__setitem__('items', items)
return response
elif format == 'xml':
response = get_xml_description(gadgetlist, user)
response = HttpResponse(response,mimetype='text/xml; charset=UTF-8')
response.__setitem__('items', items)
return response
else:
return HttpResponseServerError(get_xml_error(_("Invalid format. Format must be either xml or json")), mimetype='application/xml; charset=UTF-8')
def get(self, request, *args, **kw):
# Process any get params that you may need
# If you don't need to process get params,
# you can skip this part
get_arg1 = request.GET.get('arg1', None)
get_arg2 = request.GET.get('arg2', None)
id = int(kw['id'])
print "["+str(id)+"]"
# Any URL parameters get passed in **kw
doc = settings.GLOBAL_LOAD.docList.docs[id]
print doc.fileName
result = doc.toJSON()
print result + "qsf"
response = HttpResponse(result, content_type='application/json')
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def showCover(request):
news_id=request.GET.get('news_id')
print 'news_id:'+news_id
# 创建Session:
session=db.db_createSession()
# 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行:
img = session.query(Image).filter(Image.news_id==news_id).one()
if img:
resJSON='{"cover":"http://54.223.148.123:8090/static/images/'+img.news_cover+'"}'
else:
resJSON='{"cover":"none"}'
response = HttpResponse(json.dumps(resJSON))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
session.close()
return response
def home(request):
data = urlopen('http://www.cs.washington.edu/research/xmldatasets/data/courses/reed.xml')
xml = XML(data.read())
data.close()
store = Graph()
subject = URIRef('http://rdf.ify.dk/#subject')
title = URIRef('http://rdf.ify.dk/#title')
course = URIRef('http://rdf.ify.dk/#course')
for i in xml.iterfind('course'):
c = BNode()
store.add((c, RDF.type, course))
store.add((c, title, Literal(i.find('title').text)))
store.add((c, subject, Literal(i.find('subj').text)))
r = HttpResponse(store.serialize(format='pretty-xml'), content_type='application/rdf+xml')
r.__setitem__('Content-Disposition', 'attachment; filename="courses.rdf"')
return r
def test_headers_type(self):
r = HttpResponse()
# ASCII strings or bytes values are converted to strings.
r['key'] = 'test'
self.assertEqual(r['key'], 'test')
r['key'] = 'test'.encode('ascii')
self.assertEqual(r['key'], 'test')
self.assertIn(b'test', r.serialize_headers())
# Non-ASCII values are serialized to Latin-1.
r['key'] = 'café'
self.assertIn('café'.encode('latin-1'), r.serialize_headers())
# Other unicode values are MIME-encoded (there's no way to pass them as bytes).
r['key'] = '†'
self.assertEqual(r['key'], '=?utf-8?b?4oCg?=')
self.assertIn(b'=?utf-8?b?4oCg?=', r.serialize_headers())
# The response also converts string or bytes keys to strings, but requires
# them to contain ASCII
r = HttpResponse()
del r['Content-Type']
r['foo'] = 'bar'
headers = list(r.items())
self.assertEqual(len(headers), 1)
self.assertEqual(headers[0], ('foo', 'bar'))
r = HttpResponse()
del r['Content-Type']
r[b'foo'] = 'bar'
headers = list(r.items())
self.assertEqual(len(headers), 1)
self.assertEqual(headers[0], ('foo', 'bar'))
self.assertIsInstance(headers[0][0], str)
r = HttpResponse()
with self.assertRaises(UnicodeError):
r.__setitem__('føø', 'bar')
with self.assertRaises(UnicodeError):
r.__setitem__('føø'.encode(), 'bar')
def energyMeter(request):
if request.method == 'GET':
meter = 100
if 'meter' in request.GET.keys():
meter = request.GET['meter']
meters = GHGEnergyMeter.objects.filter(meter=meter).order_by('-timestamp')[:10]
serializer = GHGEnergyMeterSerializer(meters, many=True)
content = JSONRenderer().render(serializer.data)
response = HttpResponse(content, content_type="application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
elif request.method == 'POST':
data = JSONParser().parse(request)
serializer = GHGEnergyMeterSerializer(data=data)
if serializer.is_valid():
serializer.save()
return HttpResponse('{ "result" : "success" }', status=201, content_type="application/json")
return HttpResponse(serializer.errors, status=400, content_type="application/json")
else:
return HttpResponse("Invalid request", status=500)
def uploadSingle(request):
'''receives an uploaded image from user and save it to the
test folder, aswell as normalizing it to a test_normalized folder'''
if request.method == "POST":
uploaded_image = request.FILES['upload']
name = uploaded_image.name
test_path = os.path.join(TEST_DIR,name)
fil = open(test_path,"wb")
data = uploaded_image.read()
fil.write(data)
fil.close()
ntest_path = os.path.join(NTEST_DIR,name)
norm_fil = open(ntest_path,"wb")
norm_fil.write(data)
norm_fil.close()
tt.prepare_directory(NTEST_DIR,(100,100))
response = HttpResponse("file uploaded successfully")
response.__setitem__("content-type","text/text")
return response
def ding(request):
m_MiscData=request.GET.dict()
particle = ParticleLib.objects.get(int(m_MiscData["id"]))
particle.ding_count=particle.ding_count1;
particle.save()
resp=HttpResponse("1")
resp.__setitem__("Access-Control-Allow-Origin","*")
resp.__setitem__("Access-Control-Allow-Headers","X-Requested-With")
resp.__setitem__("Access-Control-Allow-Methods","PUT,POST,GET,DELETE,OPTIONS")
return resp
def getParticleList(request):
particle_list = ParticleLib.objects.all().order_by('-particle_create_time')[0:100]
data_array=[]
for obj in particle_list:
data_array.append(model_to_dict(obj))
pass
encodedjson = json.dumps(data_array)
resp=HttpResponse(encodedjson)
resp.__setitem__("Access-Control-Allow-Origin","*")
resp.__setitem__("Access-Control-Allow-Headers","X-Requested-With")
resp.__setitem__("Access-Control-Allow-Methods","PUT,POST,GET,DELETE,OPTIONS")
return resp
def getInviteCode(request):
user_id = request.GET.get('user_id')
user_email = request.GET.get('user_email')
print user_id
print user_email
if len(user_id) == 11 and user_email:
session = db.db_createSession()
invite = session.query(Invite).filter(Invite.user_id == user_id).all()
if len(invite) == 1:
if not invite[0].invite_code:
chars = string.ascii_letters + string.digits
inviteCode = ''.join([random.choice(chars) for i in range(11)])
print inviteCode
invite[0].invite_code = inviteCode
invite[0].user_email = user_email
session.add(invite[0])
session.commit()
session.close()
elif invite[0].user_email == user_email:
inviteCode = invite[0].invite_code
else:
response = HttpResponse(json.dumps('{"result":"invalid"}'))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
response = HttpResponse(json.dumps('{"result":"' + inviteCode + '"}'))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
else:
response = HttpResponse(json.dumps('{"result":"invalid"}'))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
else:
response = HttpResponse(json.dumps('{"result":"invalid"}'))
response.__setitem__("Content-type", "application/json")
response.__setitem__("Access-Control-Allow-Origin", "*")
return response
def addParticle(request):
m_RawData=ParticleLib()
m_MiscData=request.POST.dict()
m_RawData.user_uuid=m_MiscData["user_uuid"]
m_RawData.particle_name=m_MiscData["particle_name"]
m_RawData.particle_img=m_MiscData["particle_img"]
m_RawData.particle_data=m_MiscData["particle_data"]
m_RawData.save()
resp=HttpResponse("1")
resp.__setitem__("Access-Control-Allow-Origin","*")
resp.__setitem__("Access-Control-Allow-Headers","X-Requested-With")
resp.__setitem__("Access-Control-Allow-Methods","PUT,POST,GET,DELETE,OPTIONS")
return resp
