def delete_friends(request):
current_username = request.POST.get('username')
current_friendName = request.POST.get('friendUsername')
ol=[]
try:
existingUser = FriendList.objects.get(user__username = current_username)
user_friends = existingUser.getfoo()
for c in user_friends:
c = unicodedata.normalize('NFKD', c).encode('ascii','ignore')
if(c == current_friendName):
continue
ol.append(c)
existingUser.friendList = json.dumps(ol)
existingUser.save()
except:
ol=[]
return HttpResponse(json.dumps(ol))
python类HttpResponse()的实例源码
def download_annotated(request, individual_id):
individual = get_object_or_404(Individual, pk=individual_id)
filepath = os.path.dirname(str(individual.vcf_file.name))
filename = os.path.basename(str(individual.vcf_file.name))
# path = settings.MEDIA_ROOT
# if filename.endswith('vcf.zip'):
# basename = filename.split('.vcf.zip')[0]
# else:
basename = filename.split('.vcf')[0]
fullpath = '%s/annotation.final.vcf.zip' % (filepath)
vcffile = open(fullpath, 'rb')
response = HttpResponse(vcffile, content_type='application/x-zip-compressed')
# # response['Content-Encoding'] = 'gzip'
response['Content-Disposition'] = 'attachment; filename=%s.annotated.mendelmd.vcf.zip' % basename
response['Content-Length'] = os.path.getsize(fullpath)
return response
def export_to_csv(request, variants):
#export to csv
export = request.GET.get('export', '')
if export != '':
if export == 'csv':
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename=export.csv'
writer = csv.writer(response)
elif export == 'txt':
response = HttpResponse(content_type='text/plain')
response['Content-Disposition'] = 'attachment; filename=export.txt'
writer = csv.writer(response, delimiter='\t', quoting=csv.QUOTE_NONE)
writer.writerow(['Individual', 'Index', 'Pos_index', 'Chr', 'Pos', 'Variant_id', 'Ref', 'Alt', 'Qual', 'Filter', 'Info', 'Format', 'Genotype_col', 'Genotype', 'Read_depth', 'Gene', 'Mutation_type', 'Vartype', 'Genomes1k_maf', 'Dbsnp_maf', 'Esp_maf', 'Dbsnp_build', 'Sift', 'Sift_pred', 'Polyphen2', 'Polyphen2_pred', 'Condel', 'Condel_pred', 'DANN', 'CADD', 'Is_at_omim', 'Is_at_hgmd', 'Hgmd_entries', 'Effect', 'Impact', 'Func_class', 'Codon_change', 'Aa_change', 'Aa_len', 'Gene_name', 'Biotype', 'Gene_coding', 'Transcript_id', 'Exon_rank', 'Genotype_number', 'Allele', 'Gene', 'Feature', 'Feature_type', 'Consequence', 'Cdna_position', 'Cds_position', 'Protein_position', 'Amino_acids', 'Codons', 'Existing_variation', 'Distance', 'Strand', 'Symbol', 'Symbol_source', 'Sift', 'Polyphen', 'Condel'])
for variant in variants:
# print 'variant', variant.index
writer.writerow([variant.individual, variant.index, variant.pos_index, variant.chr, variant.pos, variant.variant_id, variant.ref, variant.alt, variant.qual, variant.filter, pickle.loads(variant.info), variant.format, variant.genotype_col, variant.genotype, variant.read_depth, variant.gene, variant.mutation_type, variant.vartype, variant.genomes1k_maf, variant.dbsnp_maf, variant.esp_maf, variant.dbsnp_build, variant.sift, variant.sift_pred, variant.polyphen2, variant.polyphen2_pred, variant.condel, variant.condel_pred, variant.dann, variant.cadd, variant.is_at_omim, variant.is_at_hgmd, variant.hgmd_entries])
return response
def execute(request):
p_stud = request.GET.get('pStud', '')
p_token = request.GET.get('pToken', '')
if(p_stud == '' or p_token == ''):
return HttpResponse("error")
# simple proxy
# download content from the url
url = ''.join(["https://campus.tum.de/tumonlinej/ws/termin/ical?pStud=",p_stud,"&pToken=",p_token])
print(url)
response = urllib.request.urlopen(url)
data = response.read()
#text = data.decode('utf-8')
return HttpResponse(tumtools.execute(data), content_type="text/calendar")
def post(self, request):
if "HTTP_PAYPAL_TRANSMISSION_ID" not in request.META:
# Do not even attempt to process/store the event if there is
# no paypal transmission id so we avoid overfilling the db.
return HttpResponseBadRequest()
trigger = WebhookEventTrigger.from_request(request)
if trigger.exception:
# An exception happened, return 500
return HttpResponseServerError()
if not trigger.valid:
# Webhook Event did not validate, return 400
return HttpResponseBadRequest()
return HttpResponse(str(trigger.id))
def get(self, request, server_id, character_id):
server = self.get_server(request, server_id)
if server is None:
return HttpResponse('server does not exist', status=400)
character = (Character.objects
.filter(
server_id=server.id,
id=character_id)
.first())
if character is None:
return HttpResponse('character does not exist', status=400)
histories = CharacterHistory.objects.filter(character_id=character.id)
serialized = CharacterHistorySerializer(histories, many=True).data
return JsonResponse({'history': serialized}, status=200)
def get(self, request, server_id, character_id):
server = self.get_server(request, server_id)
if server is None:
return HttpResponse('server does not exist', status=400)
character = (Character.objects
.filter(
server_id=server.id,
id=character_id)
.first())
if character is None:
return HttpResponse('character does not exist', status=400)
serialized = CharacterSerializer(character).data
return JsonResponse(serialized, status=200)
def post(self, request, server_id):
if 'private_secret' not in request.GET:
return HttpResponse('missing required param private_secret', status=400)
server = (Server.objects
.filter(id=server_id, private_secret=request.GET['private_secret'])
.first())
if server is None:
return HttpResponse('server does not exist', status=404)
data = json.loads(request.body)
if 'characters' in data:
sync_characters_task.delay(server.id, data['characters'], request.GET)
if 'clans' in data:
sync_clans_task.delay(server.id, data['clans'])
server.last_sync = timezone.now()
server.save()
delete_old_history.delay()
return HttpResponse(status=200)
def post(self, request, server_id):
if 'private_secret' not in request.GET:
return HttpResponse('missing required param private_secret')
data = request.GET
server = self.get_server(request, server_id)
if server is None:
return HttpResponse('server does not exist', status=404)
if 'name' in data:
server.name = data['name']
server.save()
serialized = ServerAdminSerializer(server).data
return JsonResponse(serialized, status=200)
def get(self, request, server_id, clan_id):
server = self.get_server(request, server_id)
if server is None:
return HttpResponse('server does not exist', status=400)
clan = (Clan.objects
.filter(
server_id=server.id,
id=clan_id)
.first())
if clan is None:
return HttpResponse('clan does not exist', status=400)
serialized = ClanSerializer(clan).data
return JsonResponse(serialized, status=200)
def test_instance_log(self):
server = self.servers.first()
CONSOLE_OUTPUT = 'output'
api.nova.server_console_output(IsA(http.HttpRequest),
server.id, tail_length=None) \
.AndReturn(CONSOLE_OUTPUT)
self.mox.ReplayAll()
url = reverse('horizon:project:instances:console',
args=[server.id])
tg = tabs.InstanceDetailTabs(self.request, instance=server)
qs = "?%s=%s" % (tg.param_name, tg.get_tab("log").get_id())
res = self.client.get(url + qs)
self.assertNoMessages()
self.assertIsInstance(res, http.HttpResponse)
self.assertContains(res, CONSOLE_OUTPUT)
def get(self, request, keypair_name=None, optional=None):
try:
if optional == "regenerate":
api.nova.keypair_delete(request, keypair_name)
keypair = api.nova.keypair_create(request, keypair_name)
except Exception:
redirect = reverse('horizon:project:access_and_security:index')
exceptions.handle(self.request,
_('Unable to create key pair: %(exc)s'),
redirect=redirect)
response = http.HttpResponse(content_type='application/binary')
response['Content-Disposition'] = ('attachment; filename=%s.pem'
% slugify(keypair.name))
response.write(keypair.private_key)
response['Content-Length'] = str(len(response.content))
return response
def test_wrap_list_rendering(self):
self.table = MyTableWrapList(self.request, TEST_DATA_7)
row = self.table.get_rows()[0]
name_cell = row.cells['name']
value_cell = row.cells['value']
optional_cell = row.cells['optional']
# Check if is cell is rendered correctly.
name_cell_rendered = name_cell.render()
value_cell_rendered = value_cell.render()
optional_cell_rendered = optional_cell.render()
resp_name = http.HttpResponse(name_cell_rendered)
resp_value = http.HttpResponse(value_cell_rendered)
resp_optional = http.HttpResponse(optional_cell_rendered)
self.assertContains(resp_name, '<ul>wrapped name</ul>', 1)
self.assertContains(resp_value, '<ul>wrapped value</ul>', 1)
self.assertContains(resp_optional, 'not wrapped optional', 1)
self.assertNotContains(resp_optional, '<ul>')
self.assertNotContains(resp_optional, '</ul>')
def test_inline_edit_available_cell_rendering(self):
self.table = MyTable(self.request, TEST_DATA_2)
row = self.table.get_rows()[0]
name_cell = row.cells['name']
# Check if in-line edit is available in the cell,
# but is not in inline_edit_mod.
self.assertTrue(name_cell.inline_edit_available)
self.assertFalse(name_cell.inline_edit_mod)
# Check if is cell is rendered correctly.
name_cell_rendered = name_cell.render()
resp = http.HttpResponse(name_cell_rendered)
self.assertContains(resp, '<td', 1)
self.assertContains(resp, 'inline_edit_available', 1)
self.assertContains(resp,
'data-update-url="?action=cell_update&'
'table=my_table&cell_name=name&obj_id=1"',
1)
self.assertContains(resp, 'table_cell_wrapper', 1)
self.assertContains(resp, 'table_cell_data_wrapper', 1)
self.assertContains(resp, 'table_cell_action', 1)
self.assertContains(resp, 'ajax-inline-edit', 1)
def test_inline_edit_available_not_allowed_cell_rendering(self):
self.table = MyTableNotAllowedInlineEdit(self.request, TEST_DATA_2)
row = self.table.get_rows()[0]
name_cell = row.cells['name']
# Check if in-line edit is available in the cell,
# but is not in inline_edit_mod.
self.assertTrue(name_cell.inline_edit_available)
self.assertFalse(name_cell.inline_edit_mod)
# Check if is cell is rendered correctly.
name_cell_rendered = name_cell.render()
resp = http.HttpResponse(name_cell_rendered)
self.assertContains(resp, '<td', 1)
self.assertContains(resp, 'inline_edit_available', 1)
self.assertContains(resp,
'data-update-url="?action=cell_update&'
'table=my_table&cell_name=name&obj_id=1"',
1)
self.assertContains(resp, 'table_cell_wrapper', 0)
self.assertContains(resp, 'table_cell_data_wrapper', 0)
self.assertContains(resp, 'table_cell_action', 0)
self.assertContains(resp, 'ajax-inline-edit', 0)
def test_table_action_attributes(self):
table = MyTable(self.request, TEST_DATA)
self.assertTrue(table.has_actions)
self.assertTrue(table.needs_form_wrapper)
res = http.HttpResponse(table.render())
self.assertContains(res, "<form")
table = MyTable(self.request, TEST_DATA, needs_form_wrapper=False)
self.assertTrue(table.has_actions)
self.assertFalse(table.needs_form_wrapper)
res = http.HttpResponse(table.render())
self.assertNotContains(res, "<form")
table = NoActionsTable(self.request, TEST_DATA)
self.assertFalse(table.has_actions)
self.assertFalse(table.needs_form_wrapper)
res = http.HttpResponse(table.render())
self.assertNotContains(res, "<form")
def serve(self, request, file_obj, **kwargs):
fullpath = file_obj.path
# the following code is largely borrowed from `django.views.static.serve`
# and django-filetransfers: filetransfers.backends.default
if not os.path.exists(fullpath):
raise Http404('"%s" does not exist' % fullpath)
# Respect the If-Modified-Since header.
statobj = os.stat(fullpath)
content_type_key = 'mimetype' if LTE_DJANGO_1_4 else 'content_type'
response_params = {content_type_key: self.get_mimetype(fullpath)}
if not was_modified_since(request.META.get('HTTP_IF_MODIFIED_SINCE'),
statobj[stat.ST_MTIME], statobj[stat.ST_SIZE]):
return HttpResponseNotModified(**response_params)
response = HttpResponse(open(fullpath, 'rb').read(), **response_params)
response["Last-Modified"] = http_date(statobj[stat.ST_MTIME])
self.default_headers(request=request, response=response, file_obj=file_obj, **kwargs)
return response
def host_meta_view(request):
"""Generate a `.well-known/host-meta` document"""
host_meta = generate_host_meta("diaspora", webfinger_host=settings.SOCIALHOME_URL)
return HttpResponse(host_meta, content_type="application/xrd+xml")
