def download(modeladmin, request, selected):
buf = StringIO('This is the content of the file')
return StreamingHttpResponse(FileWrapper(buf))
def container_stats(request, container_id):
container = Container.objects.get_container(container_id, request.user)
if container:
return StreamingHttpResponse(stream_response_generator(container))
return render(request, 'no_access.html')
def host_stats(request):
return StreamingHttpResponse(stream_host_stats())
def dataset_detail(request, slug, tablename=""):
try:
dataset = Dataset.objects.get(slug=slug)
except Dataset.DoesNotExist:
context = {'message': 'Dataset does not exist'}
return render(request, '404.html', context, status=404)
if not tablename:
tablename = dataset.get_default_table().name
return redirect(
reverse(
"core:dataset-table-detail",
kwargs={
"slug": slug,
"tablename": tablename
},
))
try:
table = dataset.get_table(tablename)
except Table.DoesNotExist:
context = {'message': 'Table does not exist'}
return render(request, '404.html', context, status=404)
querystring = request.GET.copy()
page_number = querystring.pop("page", ["1"])[0].strip() or "1"
download_csv = querystring.pop("format", [""]) == ["csv"]
try:
page = int(page_number)
except ValueError:
context = {'message': 'Invalid page number.'}
return render(request, '404.html', context, status=404)
version = dataset.version_set.order_by("-order").first()
fields = table.fields
all_data = table.get_model().objects.filter_by_querystring(querystring)
if download_csv:
if all_data.count() > max_export_rows:
context = {"message": "Max rows exceeded."}
return render(request, '404.html', context, status=400)
filename = "{}-{}.csv".format(slug, uuid.uuid4().hex)
pseudo_buffer = Echo()
writer = csv.writer(pseudo_buffer, dialect=csv.excel)
csv_rows = queryset_to_csv(all_data, fields)
response = StreamingHttpResponse(
(writer.writerow(row) for row in csv_rows),
content_type="text/csv;charset=UTF-8",
)
response["Content-Disposition"] = 'attachment; filename="{}"'.format(
filename)
response.encoding = "UTF-8"
return response
paginator = Paginator(all_data, 20)
data = paginator.get_page(page)
for key, value in list(querystring.items()):
if not value:
del querystring[key]
context = {
"data": data,
"dataset": dataset,
"table": table,
"fields": fields,
"max_export_rows": max_export_rows,
"query_dict": querystring,
"querystring": querystring.urlencode(),
"slug": slug,
"table": table,
"total_count": all_data.count(),
"version": version,
}
return render(request, "dataset-detail.html", context)
def download(self, request: Request, token=None):
media: Media = self.get_object()
response = StreamingHttpResponse(media.file, content_type=media.mime)
response[
'Content-Disposition'] = f'attachment; filename={media.filename}'
return response
def retrieve(self, request: Request, token=None):
media: Media = self.get_object()
return StreamingHttpResponse(media.file, content_type=media.mime)
def video_feed(request):
return StreamingHttpResponse(
gen(VideoCamera()),
content_type='multipart/x-mixed-replace; boundary=frame')
def displayMap(request, arg):
if request.method == 'POST':
if request.POST.get('reportReason', "").strip() != "":
checkReports = Reports.objects.filter(user_id=request.user.id,
ex_id=arg,
ex_name='maps')
if not checkReports:
checkReports = Reports.objects.filter(ex_id=arg,
ex_name='maps')
infringement = request.POST.get('infringement', False)
if infringement == "true":
infringement = True
transac = Reports(
user_id=request.user.id,
reason=request.POST['reportReason'].strip(),
ex_id=arg,
ex_name='maps',
infringement=infringement,
posted=timezone.now(),
)
transac.save()
Maps.objects.filter(id=arg).update(
amount_reports=F('amount_reports') + 1)
misc.send_email_to_admin_OnReport({
'addr':
request.META['HTTP_HOST'] + '/maps/' + arg,
'user_id':
request.user.id,
'reason':
request.POST['reportReason'].strip(),
'infringement':
infringement
})
misc.send_email_to_user_OnReport({
'addr':
request.META['HTTP_HOST'] + '/maps/' + arg,
'owner_id':
Maps.objects.get(id=arg).user_id,
'reason':
request.POST['reportReason'].strip(),
'resource_type':
'map'
})
return HttpResponseRedirect('/maps/' + arg)
elif request.POST.get('mapInfo', False) is not False:
if request.user.is_superuser:
Maps.objects.filter(id=arg).update(
info=request.POST['mapInfo'].strip())
else:
Maps.objects.filter(id=arg, user_id=request.user.id).update(
info=request.POST['mapInfo'].strip())
return HttpResponseRedirect('/maps/' + arg)
elif request.FILES.get('screenshot', False) is not False:
handlers.addScreenshot(request, arg, 'map')
elif request.POST.get('comment', "") != "":
account_age = misc.user_account_age(request.user)
if account_age < 24:
template = loader.get_template('index.html')
template_args = {
'content': 'new_user_action_blocked.html',
'hours_remaining': 24 - int(account_age),
'title': ' - Action Blocked',
}
return StreamingHttpResponse(
template.render(template_args, request))
transac = Comments(
item_type='maps',
item_id=int(arg),
user=request.user,
content=request.POST['comment'].strip(),
posted=timezone.now(),
is_removed=False,
)
transac.save()
commented_map_obj = Maps.objects.get(id=arg)
if commented_map_obj.user != request.user:
misc.send_email_to_user_OnComment('maps',
arg,
commented_map_obj.user.email,
info="owner")
comsObj = Comments.objects.filter(item_type='maps',
item_id=arg,
is_removed=False)
if comsObj:
for com in comsObj:
if com.user != request.user and com.user != commented_map_obj.user:
unsubObj = UnsubscribeComments.objects.filter(
item_type='maps', item_id=arg, user=com.user)
if not unsubObj:
misc.send_email_to_user_OnComment(
'maps', arg, com.user.email)
return HttpResponseRedirect('/maps/' + arg + '/')
path = os.path.join(settings.BASE_DIR,
__name__.split('.')[0], 'data', 'maps', arg)
oramap_filename = misc.first_oramap_in_directory(path)
if not oramap_filename:
return HttpResponseRedirect('/')
try:
mapObject = Maps.objects.get(id=arg)
except:
return HttpResponseRedirect('/')
disk_size = os.path.getsize(os.path.join(path, oramap_filename))
disk_size = misc.sizeof_fmt(disk_size)
lints = []
lintObject = Lints.objects.filter(map_id=mapObject.id, item_type='maps')
lintObject = sorted(lintObject, key=lambda x: (x.posted), reverse=False)
for lint_item in lintObject:
lints.append([
lint_item.version_tag, lint_item.pass_status, lint_item.lint_output
])
reportedByUser = False
reports = []
reportObject = Reports.objects.filter(ex_id=mapObject.id, ex_name='maps')
for item in reportObject:
try:
usr = User.objects.get(pk=item.user_id)
reports.append(
[usr.username, item.reason, item.infringement, item.posted])
except:
pass
if item.user_id == request.user.id:
reportedByUser = True
luaNames = []
listContent = os.listdir(os.path.join(path, 'content'))
for fn in listContent:
if fn.endswith('.lua'):
luaNames.append(os.path.splitext(fn)[0])
mapsFromAuthor = Maps.objects.filter(
author=mapObject.author,
next_rev=0).exclude(id=mapObject.id).distinct('map_hash').order_by(
'map_hash', '-posted').exclude(map_hash=mapObject.map_hash)
if len(mapsFromAuthor) >= 8:
mapsFromAuthor = random.sample(list(mapsFromAuthor), 8)
else:
mapsFromAuthor = random.sample(list(mapsFromAuthor),
len(mapsFromAuthor))
similarMaps = Maps.objects.filter(
next_rev=0,
game_mod=mapObject.game_mod,
tileset=mapObject.tileset,
players=mapObject.players,
map_type=mapObject.map_type,
width=mapObject.width,
height=mapObject.height).exclude(map_hash=mapObject.map_hash)[0:8]
duplicates = Maps.objects.filter(map_hash=mapObject.map_hash).exclude(
id=mapObject.id)
if duplicates:
duplicates = True
screenshots = Screenshots.objects.filter(ex_name="maps", ex_id=arg)
try:
played_counter = urllib.request.urlopen(
"http://master.openra.net/map_stats?hash=%s" %
mapObject.map_hash).read().decode()
played_counter = json.loads(played_counter)
if played_counter:
played_counter = played_counter["played"]
else:
played_counter = 0
except:
played_counter = 'unknown'
ratesAmount = Rating.objects.filter(ex_id=mapObject.id, ex_name='map')
ratesAmount = len(ratesAmount)
comments = misc.get_comments_for_all_revisions(request, 'maps', arg)
# showing upgrade map button
show_upgrade_map_button = True
if not (request.user == mapObject.user or request.user.is_superuser):
show_upgrade_map_button = False
if mapObject.next_rev != 0:
show_upgrade_map_button = False # upgrade only the latest revision
if not any([
mapObject.parser in v
for v in settings.OPENRA_UPDATE_VERSIONS.values()
]):
show_upgrade_map_button = False # no compatible update targets
###
map_preview = None
for sc_item in screenshots:
if sc_item.map_preview:
map_preview = sc_item
license, icons = misc.selectLicenceInfo(mapObject)
userObject = User.objects.get(pk=mapObject.user_id)
Maps.objects.filter(id=mapObject.id).update(viewed=mapObject.viewed + 1)
has_upgrade_logs = mapObject.mapupgradelogs_set.count() > 0
template = loader.get_template('index.html')
template_args = {
'content': 'displayMap.html',
'request': request,
'title': ' - Map details - ' + mapObject.title,
'map': mapObject,
'userid': userObject,
'arg': arg,
'license': license,
'icons': icons,
'reports': reports,
'reported': reportedByUser,
'luaNames': luaNames,
'mapsFromAuthor': mapsFromAuthor,
'similarMaps': similarMaps,
'screenshots': screenshots,
'disk_size': disk_size,
'duplicates': duplicates,
'played_counter': played_counter,
'ratesAmount': ratesAmount,
'REPORTS_PENALTY_AMOUNT': settings.REPORTS_PENALTY_AMOUNT,
'lints': lints,
'comments': comments,
'show_upgrade_map_button': show_upgrade_map_button,
'map_preview': map_preview,
'last_parser': settings.OPENRA_VERSIONS[0],
'has_upgrade_logs': has_upgrade_logs
}
return StreamingHttpResponse(template.render(template_args, request))
