def test_objectgetter(self):
request = HttpRequest()
book = Book.objects.get(pk=1)
self.assertEqual(book, objectgetter(Book)(request, pk=1))
self.assertEqual(book, objectgetter(Book, attr_name='id')(request, id=1))
self.assertEqual(book, objectgetter(Book, field_name='id')(request, pk=1))
with self.assertRaises(ImproperlyConfigured):
# Raise if no `pk` argument is provided to the view
self.assertEqual(book, objectgetter(Book)(request, foo=1))
with self.assertRaises(ImproperlyConfigured):
# Raise if given invalid model lookup field
self.assertEqual(book, objectgetter(Book, field_name='foo')(request, pk=1))
with self.assertRaises(Http404):
# Raise 404 if no model instance found
self.assertEqual(book, objectgetter(Book)(request, pk=100000))
def test_objectgetter(self):
request = HttpRequest()
book = Book.objects.get(pk=1)
self.assertEqual(book, objectgetter(Book)(request, pk=1))
self.assertEqual(book, objectgetter(Book, attr_name='id')(request, id=1))
self.assertEqual(book, objectgetter(Book, field_name='id')(request, pk=1))
with self.assertRaises(ImproperlyConfigured):
# Raise if no `pk` argument is provided to the view
self.assertEqual(book, objectgetter(Book)(request, foo=1))
with self.assertRaises(ImproperlyConfigured):
# Raise if given invalid model lookup field
self.assertEqual(book, objectgetter(Book, field_name='foo')(request, pk=1))
with self.assertRaises(Http404):
# Raise 404 if no model instance found
self.assertEqual(book, objectgetter(Book)(request, pk=100000))
from crispy_forms.utils import render_crispy_form
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.http import JsonResponse
from django.shortcuts import get_object_or_404
from django.template.context_processors import csrf
from django.template.loader import render_to_string
from rules.contrib.views import permission_required, objectgetter
from booking.forms import BookingForm
from booking.models import Booking
@permission_required("booking.change_booking",
fn=objectgetter(Booking, "booking_id"))
def delete_booking(request, booking_id):
booking = get_object_or_404(Booking, pk=booking_id)
booking.delete()
return JsonResponse({
"success": True,
})
@login_required
def edit_booking(request, booking_id=None):
"""
View for adding a new booking to the database.
:param booking_id:
:param request:
:return:
from django.contrib.auth.decorators import login_required
from django.shortcuts import get_object_or_404, render
from rules.contrib.views import permission_required, objectgetter
from main.models import Competition, Entry
@login_required
@permission_required('main.manage_competition',
fn=objectgetter(Competition,
attr_name='comp_id',
field_name='pk'),
raise_exception=True)
def check_in(request, org_slug, comp_id):
competition = get_object_or_404(Competition, pk=comp_id)
entries = competition.entry_set.order_by('competitor__name').all()
return render(request, 'ui/competition/check_in.html', {
'competition': competition,
'entries': entries
})
job = queue.fetch_job('tf_annotation.create/{}'.format(tid))
if job is not None:
result[tid] = {
"active": job.is_queued or job.is_started,
"success": not job.is_failed
}
return JsonResponse(result)
except Exception as ex:
slogger.glob.exception('exception was occured during tf meta request', exc_info=True)
return HttpResponseBadRequest(str(ex))
@login_required
@permission_required(perm=['engine.task.change'],
fn=objectgetter(TaskModel, 'tid'), raise_exception=True)
def create(request, tid):
slogger.glob.info('tf annotation create request for task {}'.format(tid))
try:
db_task = TaskModel.objects.get(pk=tid)
queue = django_rq.get_queue('low')
job = queue.fetch_job('tf_annotation.create/{}'.format(tid))
if job is not None and (job.is_started or job.is_queued):
raise Exception("The process is already running")
db_labels = db_task.label_set.prefetch_related('attributespec_set').all()
db_labels = {db_label.id:db_label.name for db_label in db_labels}
tf_annotation_labels = {
"person": 1, "bicycle": 2, "car": 3, "motorcycle": 4, "airplane": 5,
"bus": 6, "train": 7, "truck": 8, "boat": 9, "traffic_light": 10,
)
return render(
request, "formation_detail.html",
{
'formation': formation,
'can_edit_formation': can_edit_formation,
}
)
else:
raise Http404()
@login_required
@permission_required(
'continuing_education.change_continuingeducationtraining',
fn=objectgetter(ContinuingEducationTraining, 'formation_id'),
raise_exception=True
)
def formation_edit(request, formation_id):
formation = get_object_or_404(
ContinuingEducationTraining.objects.select_related('postal_address', 'education_group'),
pk=formation_id
)
form = ContinuingEducationTrainingForm(request.POST or None, user=request.user, instance=formation)
address_form = AddressForm(request.POST or None, instance=formation.postal_address)
if all([form.is_valid(), address_form.is_valid()]):
address = address_form.save()
formation = form.save(commit=False)
formation.postal_address = address
formation.save()
return redirect(reverse('formation_detail', kwargs={'formation_id': formation.education_group.id}))
for view in settings.VIEWS_DISABLED:
if view in view_column_names.values():
global_views_disabled.append((list(view_column_names.keys()))[list(
view_column_names.values()).index(view)])
admin_course_views = CourseViewOption.objects.get(course=course).json(
include_id=False)
course_view_options = {
key: value
for key, value in admin_course_views.items()
if key not in global_views_disabled
}
return admin_course_views if is_admin else course_view_options
@permission_required('dashboard.get_course_info',
fn=objectgetter(Course, 'course_id', 'canvas_id'),
raise_exception=True)
def get_course_info(request, course_id=0):
"""Returns JSON data about a course
:param request: HTTP Request
:type request: Request
:param course_id: Unizin Course ID, defaults to 0
:param course_id: int, optional
:return: JSON to be used
:rtype: str
"""
course_id = canvas_id_to_incremented_id(course_id)
today = timezone.now()
try:
"status": rq_job.get_status(),
"stderr": rq_job.exc_info
})
else:
return JsonResponse({"status": "unknown"})
except Exception as ex:
slogger.glob.error(
"error occured during checking repository request with rq id {}".
format(rq_id),
exc_info=True)
return HttpResponseBadRequest(str(ex))
@login_required
@permission_required(perm=['engine.task.create'],
fn=objectgetter(models.Task, 'tid'),
raise_exception=True)
def create(request, tid):
try:
slogger.task[tid].info("create repository request")
body = json.loads(request.body.decode('utf-8'))
path = body["path"]
lfs = body["lfs"]
rq_id = "git.create.{}".format(tid)
queue = django_rq.get_queue("default")
queue.enqueue_call(func=CVATGit.initial_create,
args=(tid, path, lfs, request.user),
job_id=rq_id)
return JsonResponse({"rq_id": rq_id})
from django.http import HttpResponse
from django.views.generic.edit import UpdateView, DeleteView
from rules.contrib.views import permission_required, objectgetter
from rules.contrib.views import LoginRequiredMixin, PermissionRequiredMixin
from .models import Book
class BookMixin(object):
def get_object(self):
return Book.objects.get(pk=self.kwargs['book_id'])
@permission_required('testapp.change_book', fn=objectgetter(Book, 'book_id'))
def change_book(request, book_id):
return HttpResponse('OK')
class BookUpdateView(LoginRequiredMixin, PermissionRequiredMixin, BookMixin,
UpdateView):
fields = ['title']
template_name = 'empty.html'
permission_required = 'testapp.change_book'
@permission_required('testapp.delete_book', fn=objectgetter(Book, 'book_id'))
def delete_book(request, book_id):
return HttpResponse('OK')
def downloadThread(frames, tid, currentUser):
for frame in frames:
# Download the requested frame
frame_path = task.get_frame_path(tid, frame)
is_downloaded = downloadFile(settings.AWS_STORAGE_BUCKET_NAME, frame_path, frame_path)
# Move the frame to a new folder under the current user name
fileNameIndex = re.search(r'/\d+.jpg', frame_path)
destination_path = frame_path[:fileNameIndex.start()] + '/' + currentUser + frame_path[fileNameIndex.start():]
dir_path = frame_path[:fileNameIndex.start()] + '/' + currentUser
if not os.path.isdir(dir_path):
try:
os.mkdir(dir_path)
except FileExistsError as e:
if not os.path.isdir(dir_path):
try:
os.remove(dir_path)
os.mkdir(dir_path)
except IsADirectoryError as e:
pass
except OSError as e:
if e.errno == errno.EEXIST:
if not os.path.isdir(dir_path):
try:
os.remove(dir_path)
os.mkdir(dir_path)
except IsADirectoryError as e:
pass
if is_downloaded:
os.rename(frame_path, destination_path)
else:
copyfile(frame_path, destination_path)
def shutdownThreads(tid, currentUser):
if tid in runningThreads[currentUser]:
end_frame = runningThreads[currentUser][tid]['endFrame']
start_frame = runningThreads[currentUser][tid]['startFrame']
runningThreads[currentUser].pop(tid, None)
for frame in range(start_frame, end_frame):
if str(frame) in downloadFrames[currentUser][tid]:
downloadFrames[currentUser][tid][str(frame)].do_run = False
del downloadFrames[currentUser][tid][str(frame)]
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def exitProccess(request, tid):
if request.user.username in watershedFrames:
delete_frames_for_watershed(tid, request.user.username)
# Stop all of the running threads and delete all leftover images on the server when the user exists the task.
shutdownThreads(tid, request.user.username)
exit_tracking_process(request.user.username, tid)
for root, dirs, _ in os.walk('/home/django/data/' + str(tid)):
for d in dirs:
if os.path.join(root, d).endswith(request.user.username):
shutil.rmtree(os.path.join(root, d))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def exitFromSegmentationMode(request, tid):
delete_frames_for_watershed(tid, request.user.username)
return HttpResponse()
def delete_frames_for_watershed(tid, username):
watershedFrames.pop(username, None)
for root, dirs, _ in os.walk('/home/django/data/watershed/' + str(tid)):
for d in dirs:
if os.path.join(root, d).endswith(username):
shutil.rmtree(os.path.join(root, d))
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def frames_for_watershed(request, tid, frame):
try:
stop_frame = list(models.Segment.objects.filter(task_id=tid).values_list("stop_frame", flat=True))[0] + 1
q = django_rq.get_queue('mid')
wanted_frames = []
unwanted_frames = []
# Set the range of frames to download
if frame + 5 < stop_frame:
stop_frame = frame + 5
start_frame = frame - 2
if start_frame < 0:
start_frame = 0
# If the user is not in the watershed frames create a dictionary for him.
if request.user.username not in watershedFrames:
watershedFrames[request.user.username] = {}
if str(tid) in watershedFrames[request.user.username]:
for i in range(start_frame, stop_frame):
if i not in watershedFrames[request.user.username][str(tid)]:
wanted_frames.append(i)
for j in watershedFrames[request.user.username][str(tid)]:
if j < start_frame or j > stop_frame:
unwanted_frames.append(j)
watershedFrames[request.user.username][str(tid)] = [i for i in range(start_frame, stop_frame)]
else:
watershedFrames[request.user.username][str(tid)] = [i for i in range(start_frame, stop_frame)]
wanted_frames += watershedFrames[request.user.username][str(tid)]
for wanted_frame in wanted_frames:
q.enqueue_call(func=download_frame, args=(tid, wanted_frame, request.user.username),
job_id="task/{}.frame/{}.download_frame".format(tid, wanted_frame))
for unwanted_frame in unwanted_frames:
q.enqueue_call(func=delete_frame, args=(tid, unwanted_frame, request.user.username),
job_id="task/{}.frame/{}.delete_frame".format(tid, unwanted_frame))
return HttpResponse()
except Exception as e:
slogger.task[tid].error("cannot get frame #{} for watershed".format(frame), exc_info=True)
return HttpResponseBadRequest(str(e))
def download_frame(tid, frame, username):
frame_path = task.get_frame_path(tid, frame)
is_downloaded = downloadFile(settings.AWS_STORAGE_BUCKET_NAME, frame_path, frame_path)
# Move the frame to a new folder under the current user name
fileNameIndex = re.search(r'/\d+.jpg', frame_path)
destination_path = '/home/django/data/watershed/' + str(tid) + "/" + username + frame_path[fileNameIndex.start():]
dir_path = '/home/django/data/watershed/' + str(tid) + "/" + username
if not os.path.isdir(dir_path):
os.makedirs(dir_path)
if is_downloaded:
os.rename(frame_path, destination_path)
else:
copyfile(frame_path, destination_path)
def delete_frame(tid, frame, username):
frame_path = task.get_frame_path(tid, frame)
fileNameIndex = re.search(r'/\d+.jpg', frame_path)
destination_path = '/home/django/data/watershed/' + str(tid) + "/" + username + frame_path[fileNameIndex.start():]
os.remove(destination_path)
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
@never_cache
def get_frame_watershed(request, tid, frame):
try:
frame_watershed_path = task.get_frame_watershed_path(tid, frame)
if os.environ.get('WITH_OS') == 'True':
if os.path.exists(frame_watershed_path):
q = django_rq.get_queue('default')
q.enqueue_call(func=save_watershed_mask, args=(tid, frame),
job_id="task/{}.frame/{}.save_watershed_mask".format(tid, frame))
else:
try:
downloadFile(settings.AWS_STORAGE_BUCKET_NAME, frame_watershed_path, frame_watershed_path)
except Exception as e:
pass
if os.path.exists(frame_watershed_path):
response = FileResponse(open(frame_watershed_path, 'rb'))
else:
response = FileResponse()
return response
except Exception as e:
slogger.task[tid].error("cannot get frame #{} watershed".format(frame), exc_info=True)
return HttpResponseBadRequest(str(e))
def save_watershed_mask(tid, frame):
frame_watershed_path = task.get_frame_watershed_path(tid, frame)
copyFileToOS(frame_watershed_path, frame_watershed_path)
@login_required
@permission_required(perm=['engine.task.delete'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def delete_task(request, tid):
"""Delete the task"""
try:
slogger.glob.info("delete task #{}".format(tid))
task.delete(tid)
except Exception as e:
slogger.glob.error("cannot delete task #{}".format(tid), exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.change'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def update_task(request, tid):
"""Update labels & score for the task"""
try:
slogger.task[tid].info("update task request")
labels = request.POST['labels']
score = request.POST['score']
assignee = request.POST['assignee']
task.update(tid, labels, score, assignee)
except Exception as e:
slogger.task[tid].error("cannot update task", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.change'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def update_task_properties(request, tid):
"""Update labels for the task"""
try:
properties = json.loads(request.body.decode('utf-8'))
task.updateProperties(tid, properties)
except Exception as e:
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def get_task(request, tid):
try:
slogger.task[tid].info("get task request")
response = task.get(tid)
except Exception as e:
slogger.task[tid].error("cannot get task", exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response, safe=False)
@login_required
@permission_required(perm=['engine.job.access'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def get_job(request, jid):
try:
slogger.job[jid].info("get job #{} request".format(jid))
response = task.get_job(jid)
except Exception as e:
slogger.job[jid].error("cannot get job #{}".format(jid), exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response, safe=False)
@login_required
@permission_required(perm=['engine.job.access'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def get_task_byjob(request, jid):
try:
slogger.job[jid].info("get task by job #{} request".format(jid))
response = task.get_task_byjob(jid)
if response == {}:
return HttpResponseBadRequest(str("Can not get task by jid #{}".format(jid)))
except Exception as e:
slogger.job[jid].error("cannot get job #{}".format(jid), exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response, safe=False)
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def dump_annotation(request, tid):
try:
slogger.task[tid].info("dump annotation request")
annotation.dump(tid, annotation.FORMAT_XML, request.scheme, request.get_host())
except Exception as e:
slogger.task[tid].error("cannot dump annotation", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@gzip_page
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def check_annotation(request, tid):
try:
slogger.task[tid].info("check annotation")
response = annotation.check(tid)
except Exception as e:
slogger.task[tid].error("cannot check annotation", exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response)
@login_required
@gzip_page
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def download_annotation(request, tid):
try:
slogger.task[tid].info("get dumped annotation")
db_task = models.Task.objects.get(pk=tid)
response = sendfile(request, db_task.get_dump_path(), attachment=True,
attachment_filename='{}_{}.xml'.format(db_task.id, db_task.name))
except Exception as e:
slogger.task[tid].error("cannot get dumped annotation", exc_info=True)
return HttpResponseBadRequest(str(e))
return response
@login_required
@gzip_page
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def download_segmentation(request, tid):
try:
slogger.task[tid].info("get dumped segmentation")
db_task = models.Task.objects.get(pk=tid)
if os.environ.get('WITH_OS') == 'True':
api_host = os.environ.get('API_HOST')
api_secret = os.environ.get('API_SECRET')
payload = { 'secret' : api_secret }
payload = json.dumps(payload)
headers = {
"content-type": "application/json"
}
zip_url = "{}://{}/watershed/images?project.name={}&task.name={}".format('https' if os.environ.get('API_SECURE_SITE') == 'True' else 'http',
api_host,
db_task.project.name,
db_task.name)
response = requests.post(zip_url, data=payload, headers=headers, verify=False).content
response = HttpResponse(response, content_type='application/force-download')
else:
b = BytesIO()
imagesZipFile = zipfile.ZipFile(b, mode='w')
for frame in range(db_task.size):
frame_watershed_path = task.get_frame_watershed_path(tid, frame)
if os.path.exists(frame_watershed_path):
if db_task.mode == 'annotation':
db_task_source = models.TaskSource.objects.filter(task=db_task).filter(frame=frame)[0]
fname = db_task_source.source_name
else:
fdir, fname = os.path.split(frame_watershed_path)
zip_path = os.path.join(db_task.name, fname)
imagesZipFile.write(frame_watershed_path, zip_path)
imagesZipFile.close()
response = HttpResponse(b.getvalue(), content_type="application/x-zip-compressed")
response['Content-Disposition'] = 'attachment; filename="{}.zip"'.format(db_task.name)
except Exception as e:
slogger.task[tid].error("cannot get dumped segmentation", exc_info=True)
return HttpResponseBadRequest(str(e))
return response
@login_required
@gzip_page
@permission_required(perm=['engine.job.access'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def get_annotation(request, jid):
try:
slogger.job[jid].info("get annotation for {} job".format(jid))
response = annotation.get(jid)
except Exception as e:
slogger.job[jid].error("cannot get annotation for job {}".format(jid), exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response, safe=False)
@login_required
@permission_required(perm=['engine.job.change'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def save_annotation_for_job(request, jid):
try:
slogger.job[jid].info("save annotation for {} job".format(jid))
data = json.loads(request.body.decode('utf-8'))
if 'annotation' in data:
annotation.save_job(jid, json.loads(data['annotation']), data["taskid"], json.loads(data['frameProperties']))
if 'logs' in data:
for event in json.loads(data['logs']):
clogger.job[jid].info(json.dumps(event))
slogger.job[jid].info("annotation have been saved for the {} job".format(jid))
except RequestException as e:
slogger.job[jid].error("cannot send annotation logs for job {}".format(jid), exc_info=True)
return HttpResponseBadRequest(str(e))
except Exception as e:
slogger.job[jid].error("cannot save annotation for job {}".format(jid), exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
def parse_annotation_for_task(request, tid):
return HttpResponse(task.parseTxtToXml(request.FILES.getlist('data')[0],tid))
@login_required
@permission_required(perm=['engine.task.change'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def save_annotation_for_task(request, tid):
try:
slogger.task[tid].info("save annotation request")
data = json.loads(request.body.decode('utf-8'))
annotation.save_task(tid, data)
except Exception as e:
slogger.task[tid].error("cannot save annotation", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.change'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def delete_annotation_for_task(request, tid):
try:
slogger.task[tid].info("delete annotation request")
annotation.clear_task(tid)
except Exception as e:
slogger.task[tid].error("cannot delete annotation", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.job.change'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def save_job_status(request, jid):
try:
data = json.loads(request.body.decode('utf-8'))
status = data['status']
slogger.job[jid].info("changing job status request")
task.save_job_status(jid, status, request.user.username)
except Exception as e:
if jid:
slogger.job[jid].error("cannot change status", exc_info=True)
else:
slogger.glob.error("cannot change status", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def track_task(request, tid):
try:
shapes = json.loads(request.body.decode('utf-8'))
response = task.track_shapes(shapes, tid)
except Exception as e:
slogger.glob.error("cannot access/track", exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response, safe=False)
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def track_all(request, tid):
global entireVideoTracking
if request.user.username not in entireVideoTracking:
entireVideoTracking[request.user.username] = {}
if tid not in entireVideoTracking[request.user.username]:
entireVideoTracking[request.user.username] = {tid : {"downloaded": False, "startedDownloading": False, "video path" : "", "shapes" : {}}}
currentTask = entireVideoTracking[request.user.username][tid]
if not currentTask["downloaded"] and not currentTask["startedDownloading"]:
currentTask["startedDownloading"] = True
Thread(target=download_vid, args=(tid, currentTask,)).start()
shape = json.loads(request.body.decode('utf-8'))
if shape["id"] not in currentTask["shapes"]:
currentTask["shapes"][shape["id"]] = {"positions": {}, "stopped": False, "finished": False}
if currentTask["startedDownloading"] and not currentTask["shapes"][shape["id"]]["positions"]:
return HttpResponse("Downloading...")
if not currentTask["shapes"][shape["id"]]["positions"] and not currentTask["shapes"][shape["id"]]["finished"]:
currentTask["shapes"][shape["id"]]["Thread"] = Thread(target=track_all_video, args=(shape, currentTask,))
currentTask["shapes"][shape["id"]]["Thread"].start()
temp_dict = {"results": currentTask["shapes"][shape["id"]]["positions"], "finished": currentTask["shapes"][shape["id"]]["finished"]}
response = JsonResponse(temp_dict, safe=False)
if temp_dict["finished"]:
currentTask["shapes"].pop(shape["id"])
elif len(temp_dict["results"].keys()) > 0:
for key in list(temp_dict["results"]):
currentTask["shapes"][shape["id"]]["positions"].pop(key, None)
return response
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def pause_tracking_all(request, tid, shapeId):
if (request.user.username not in entireVideoTracking) or (tid not in entireVideoTracking[request.user.username]):
return HttpResponse("No tracker stopped")
currentTask = entireVideoTracking[request.user.username][tid]
if shapeId in currentTask["shapes"]:
currentTask["shapes"][shapeId]["stopped"] = True
else:
return HttpResponse("No tracker stopped")
currentTask["shapes"][shapeId]["Thread"].join()
response = JsonResponse({"results": currentTask["shapes"][shapeId]["positions"], "finished": currentTask["shapes"][shapeId]["finished"]}, safe=False)
currentTask["shapes"].pop(shapeId)
return response
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def exit_tracking_process(request, tid):
if entireVideoTracking:
tasks = [task for user in entireVideoTracking.values()
for task in user.keys()
if task == tid]
if len(tasks) == 1:
currentTask = entireVideoTracking[username][tid]
if os.path.exists(currentTask["video path"]):
os.remove(currentTask["video path"])
entireVideoTracking[username].pop(tid)
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def video_file_exists(request, tid):
if check_video_path(tid):
response = HttpResponse("Video file exists")
else:
response = HttpResponse("Video file does not exist")
return response
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def stop_track_task(request, tid):
try:
task.stop_tracking(tid)
except Exception as e:
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
@permission_required(perm=['engine.task.access'],
fn=objectgetter(models.Task, 'tid'), raise_exception=True)
def watershed(request, tid, frame):
try:
frame_path = "/home/django/data/watershed/" + str(tid) + "/" + request.user.username + "/" + str(frame) + ".jpg"
if not os.path.exists(frame_path):
print("download frame")
download_frame(tid, frame, request.user.username)
draws = json.loads(request.body.decode('utf-8'))
print("task watershed")
task.watershed(tid, frame, draws['status'], request.user.username)
except Exception as e:
slogger.glob.error("cannot access/watershed", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
#return JsonResponse(response, safe=False)
def save_paintings(request, tid, frame):
try:
paintings = json.loads(request.body.decode('utf-8'))
task.save_paintings(tid, frame, paintings['status'])
except Exception as e:
slogger.glob.error("cannot access/save_paintings", exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
def get_paintings(request, tid, frame):
try:
response = task.get_paintings(tid, frame)
except Exception as e:
slogger.glob.error("cannot access/get_paintings", exc_info=True)
return HttpResponseBadRequest(str(e))
return JsonResponse(response, safe=False)
@login_required
def is_staff(request):
response = {'is_staff': request.user.has_perm("engine.views.is_staff")}
return JsonResponse(response, safe=False)
@login_required
def get_username(request):
response = {'username': request.user.username}
return JsonResponse(response, safe=False)
def get_next_task(request, status, tid):
if ((request.user.has_perm('dashboard.views.isManager')) or (request.user.has_perm('dashboard.views.isAdmin'))):
response = task.nextJobIdByPriority("staff_user", status, tid)
else:
response = task.nextJobIdByPriority(request.user.username, status, tid)
return HttpResponse(response)
@login_required
def updateTaskStatus(request, newStatus, taskId):
try:
# If the new status is not validation the user must be a manager to update it
if (newStatus != 'validation'):
if (not request.user.has_perm('dashboard.views.isManager')):
return HttpResponseForbidden()
db_task = models.Task.objects.get(pk=taskId)
db_task.status = newStatus
db_task.last_viewed_frame = 0
db_task.save()
db_job = models.Job.objects.get(segment__task=db_task)
db_job.status = newStatus
db_job.save()
except Exception as e:
slogger.glob.error("cannot update the target frame for task #{}".format(tid), exc_info=True)
return HttpResponseBadRequest(str(e))
return HttpResponse()
@login_required
def isManager(request):
if (request.user.has_perm('dashboard.views.isManager')):
return HttpResponse()
else:
return HttpResponseForbidden()
def get_matomo(request):
response = None
if (os.environ.get('MATOMO')):
response = {'url': os.environ.get('MATOMO'), 'siteId': os.environ.get('MATOMO_SITE_ID'), 'userId': request.user.username}
return JsonResponse(response, safe=False)
def rq_handler(job, exc_type, exc_value, tb):
job.exc_info = "".join(traceback.format_exception_only(exc_type, exc_value))
job.save()
module = job.id.split('.')[0]
if module == 'task':
return task.rq_handler(job, exc_type, exc_value, tb)
elif module == 'annotation':
return annotation.rq_handler(job, exc_type, exc_value, tb)
return True
# NOTE: Regardless, we're only really concerned with the User
# owning the VolunteerProfile, (rather than the profile itself),
# so we'll just retrieve that here -- at the same time as
# we *enforce the consistency of the parameters in the URL*
# (otherwise we're just testing that the user knows their ID,
# not that they actually own this profile):
return get_object_or_404(
User,
pk=self.kwargs['user_pk'],
volunteerprofile=self.kwargs['volunteer_pk'],
)
@permission_required('user.is_same_user',
raise_exception=True,
fn=objectgetter(User, 'user_pk'))
def user_preferences_edit_view(request, user_pk):
userprofile = get_object_or_404(User, pk=user_pk)
if request.method == 'POST':
try:
marketplace.user.set_task_preferences(
userprofile, request.POST.getlist('preferences'))
return redirect('marketplace:user_profile', user_pk=user_pk)
except KeyError:
raise Http404
except ValueError:
pass
elif request.method == 'GET':
pass
context = {
'breadcrumb':
from django.db.models import Q
from rules.contrib.views import permission_required, objectgetter
from cvat.apps.authentication.decorators import login_required
from cvat.apps.engine.models import Task as TaskModel
from cvat.apps.authentication.auth import has_admin_role
from cvat.apps.engine.log import slogger
from .model_loader import load_labelmap
from . import model_manager
from .models import AnnotationModel
@login_required
@permission_required(perm=["engine.task.change"],
fn=objectgetter(TaskModel, "tid"),
raise_exception=True)
def cancel(request, tid):
try:
queue = django_rq.get_queue("low")
job = queue.fetch_job("auto_annotation.run.{}".format(tid))
if job is None or job.is_finished or job.is_failed:
raise Exception("Task is not being annotated currently")
elif "cancel" not in job.meta:
job.meta["cancel"] = True
job.save()
except Exception as ex:
try:
slogger.task[tid].exception(
"cannot cancel auto annotation for task #{}".format(tid),
from cvat.apps.engine.models import StatusChoice
from .downloader import download_file, download_file_m4s
from .handle_file_s3 import getFileUrl, downloadFile, copyFileToOS
from django.views.decorators.csrf import csrf_exempt
from django.contrib.auth.models import User
watershedFrames = {}
runningThreads = {}
downloadFrames = {}
entireVideoTracking = {}
MAX_WORKER_COUNT = 5
FRAMES_DOWNLOAD_BUFFER = 100
############################# High Level server API
@login_required
@permission_required(perm=['engine.job.access'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def catch_client_exception(request, jid):
data = json.loads(request.body.decode('utf-8'))
for event in data['exceptions']:
clogger.job[jid].error(json.dumps(event))
return HttpResponse()
@login_required
def dispatch_request(request):
"""An entry point to dispatch legacy requests"""
if request.method == 'GET' and 'id' in request.GET:
return render(request, 'engine/annotation.html', {
'js_3rdparty': JS_3RDPARTY.get('engine', []),
'status_list': [str(i) for i in StatusChoice]
})
from django.http import HttpResponse, JsonResponse, HttpResponseBadRequest
from django.db.models import Q
from rules.contrib.views import permission_required, objectgetter
from cvat.apps.authentication.decorators import login_required
from cvat.apps.engine.models import Task as TaskModel
from cvat.apps.authentication.auth import has_admin_role
from cvat.apps.engine.log import slogger
from .model_loader import load_labelmap
from . import model_manager
from .models import AnnotationModel
@login_required
@permission_required(perm=["engine.task.change"],
fn=objectgetter(TaskModel, "tid"), raise_exception=True)
def cancel(request, tid):
try:
queue = django_rq.get_queue("low")
job = queue.fetch_job("auto_annotation.run.{}".format(tid))
if job is None or job.is_finished or job.is_failed:
raise Exception("Task is not being annotated currently")
elif "cancel" not in job.meta:
job.meta["cancel"] = True
job.save()
except Exception as ex:
try:
slogger.task[tid].exception("cannot cancel auto annotation for task #{}".format(tid), exc_info=True)
except Exception as logger_ex:
slogger.glob.exception("exception was occured during cancel auto annotation request for task {}: {}".format(tid, str(logger_ex)), exc_info=True)
try:
controle = Controle.objects.get(pk=pk)
except Controle.DoesNotExist:
logger.exception('Control not found')
data['error_message'] = _('Contrôle inexistant')
data['result'] = 'failure'
else:
data['result'] = 'success'
data['status_display'] = controle.get_status_display()
data['control_status'] = controle.status
return JsonResponse(data)
@permission_required('risk_register.change_controle',
fn=objectgetter(Controle, 'pk'))
def change_control_status(request, pk):
if request.method == 'POST' and request.is_ajax():
data = {}
try:
controle = Controle.objects.get(pk=pk)
except Controle.DoesNotExist:
logger.exception('Controle not found')
data['error_message'] = _('Contrôle inexistant')
data['result'] = 'failure'
else:
if controle.status != request.POST.get('status'):
data['result'] = 'failure'
data['error_message'] = _('statut du contrôle désynchronisé.')
elif controle.status == 'in_progress':
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from django.views import generic
from django.contrib.auth.decorators import login_required
from rules.contrib.views import permission_required, objectgetter
from django.views.decorators.http import require_http_methods
from django.shortcuts import get_object_or_404, redirect
from django.db import IntegrityError
from .models import HelpRequest, Class
def recent_requests(user):
return HelpRequest.objects.filter(creator=user).order_by('-pub_datetime')
@permission_required('class.can_view', fn=objectgetter(Class, 'class_pk'))
def get_class(request, class_pk):
klass = get_object_or_404(Class, pk=class_pk)
requests = HelpRequest.objects.filter(klass=Class.objects.get(pk=class_pk))
if klass.can_view_private(request.user):
request_list = requests.order_by('-pub_datetime')[:]
else:
request_list = requests.filter(
public=True).order_by('-pub_datetime')[:]
if request.user.is_authenticated:
request_list = request_list | requests.filter(creator=request.user.pk)
context = {
'requests_list': request_list,
'klass': klass,
}
if request.user.has_perm('class.add_help_request'):
context['urgency_choices'] = map(lambda x: x[0].title(),
from django.contrib.auth.decorators import login_required
from django.http import HttpResponse
from django.shortcuts import get_object_or_404, render
from django.utils.translation import gettext as _
from rules.contrib.views import permission_required, objectgetter
from main.models import Stage
from .stages import manage_pool_stage, manage_cull_stage, manage_de_stage, manage_add_stage
@login_required
@permission_required('main.manage_competition',
fn=objectgetter(Stage,
attr_name='stage_id',
field_name='pk'),
raise_exception=True)
def manage_stage_router(request, org_slug, comp_id, stage_id):
stage = get_object_or_404(Stage, pk=stage_id)
if stage.type == Stage.POOL:
pool_id = stage.poolstage_set.first().id
return manage_pool_stage(request, pool_id)
elif stage.type == Stage.CULL:
cull_id = stage.cullstage_set.first().id
return manage_cull_stage(request, cull_id)
elif stage.type == Stage.DE:
de_id = stage.destage_set.first().id
return manage_de_stage(request, de_id)
elif stage.type == Stage.ADD:
add_id = stage.addstage_set.first().id
return manage_add_stage(request, add_id)
else:
return HttpResponse("Not Implemented yet")
tweet.save()
return redirect('tweet:home')
else:
form = TweetForm()
return render(request, 'tweet/tweet.html', {'form': form})
@login_required
def tdetail(request, pk):
tweet = get_object_or_404(Tweet, pk=pk)
favorite = Favorite.objects.filter(user=request.user, tweet=tweet)
return render(request, 'tweet/tdetail.html', {
'tweet': tweet,
'favorite':favorite
})
@permission_required('tweet.can_tedit',fn=objectgetter(Tweet, 'pk'))
def tedit(request, pk):
tweet = get_object_or_404(Tweet, pk=pk)
if request.method == 'POST':
form = TweetForm(request.POST, instance=tweet)
if form.is_valid():
tweet.save()
return redirect('tweet:home')
else:
form = TweetForm(instance=tweet)
return render(request, 'tweet/tweet.html', {'form': form})
@require_POST
@permission_required('tweet.can_tedit',fn=objectgetter(Tweet, 'pk'))
def tdelete(request, pk):
tweet = get_object_or_404(Tweet, pk=pk)
Only allows superusers to view the history of a Course model object in the
admin.
"""
if request.user.is_superuser:
# Hacky way to access the history_view of CourseAdmin, as I have not
# found any other way to retrieve it. This is partly caused by this
# view being the resolver of 'admin:semesterpage_course_history'.
return admin.site._registry[Course].history_view(request, course_pk)
else:
# Don't need to do anything overly clever here, as this is not a normal
# use case at all.
return redirect('/')
@permission_required(
'semesterpage.change_course',
fn=objectgetter(Course, 'course_pk'),
)
def new_course_url(request, course_pk: str) -> HttpResponse:
"""
A user has specified a URL for a course which previously had none.
This should be saved to the Course model object before redirecting
to the course homepage.
"""
homepage_url = request.GET.get('homepage_url', '')
# Need to prevent relative links
if not homepage_url[:4].lower() == 'http':
homepage_url = 'http://' + homepage_url
course = Course.objects.get(pk=int(course_pk))
course.homepage = homepage_url.strip()
def project_list(request):
return render(request, 'projects/list.html', {})
@view_with_auth(['GET', 'POST'], (IsBusiness,))
@permission_required('projects.add_project', fn=Organization.from_request, raise_exception=True)
def project_create(request):
""" Create new project
Create a new project linked to the business account
"""
return render(request, 'projects/create.html', {})
@view_with_auth(['GET'], (IsBusiness,))
@permission_required('projects.change_project', fn=objectgetter(Project, 'pk'), raise_exception=True)
def project_settings(request, pk):
project = get_object_with_check_and_log(request, Project, pk=pk)
return render(request, 'projects/settings.html', {
'project': project,
})
def playground_replacements(request, task_data):
if request.GET.get('playground', '0') == '1':
for key in task_data:
if "/samples/time-series.csv" in task_data[key]:
task_data[key] = "https://app.heartex.ai" + task_data[key]
return task_data
import json
import rq
__RQ_QUEUE_NAME = "default"
__DEXTR_HANDLER = DEXTR_HANDLER()
def _dextr_thread(db_data, frame, points):
job = rq.get_current_job()
job.meta["result"] = __DEXTR_HANDLER.handle(db_data, frame, points)
job.save_meta()
@login_required
@permission_required(perm=["engine.job.change"],
fn=objectgetter(Job, "jid"),
raise_exception=True)
def create(request, jid):
try:
data = json.loads(request.body.decode("utf-8"))
points = data["points"]
frame = int(data["frame"])
username = request.user.username
slogger.job[jid].info(
"create dextr request for the JOB: {} ".format(jid) +
"by the USER: {} on the FRAME: {}".format(username, frame))
db_data = Job.objects.select_related("segment__task__data").get(
id=jid).segment.task.data
self.request.POST)
return HttpResponseRedirect(self.get_success_url())
except KeyError as k:
form.add_error(None, str(k))
return super().form_invalid(form)
class CreateOrganizationRoleForm(ModelForm):
class Meta:
model = OrganizationRole
fields = ['role', 'user']
@permission_required('organization.staff_view',
raise_exception=True,
fn=objectgetter(Organization, 'org_pk'))
def organization_staff_view(request, org_pk):
if request.method == 'POST':
form = CreateOrganizationRoleForm(request.POST)
if form.is_valid():
organization_role = form.save(commit=False)
try:
OrganizationService.add_staff_member(request.user, org_pk,
organization_role)
messages.info(request, 'Staff member added successfully.')
return redirect('marketplace:org_staff', org_pk=org_pk)
except KeyError:
raise Http404
except ValueError:
form.add_error(
None, "This user is already a member of the organization.")
if job is not None:
result[tid] = {
"active": job.is_queued or job.is_started,
"success": not job.is_failed
}
return JsonResponse(result)
except Exception as ex:
slogger.glob.exception('exception was occured during tf meta request',
exc_info=True)
return HttpResponseBadRequest(str(ex))
@login_required
@permission_required(perm=['engine.task.change'],
fn=objectgetter(TaskModel, 'tid'),
raise_exception=True)
def create(request, tid):
slogger.glob.info('tf annotation create request for task {}'.format(tid))
try:
db_task = TaskModel.objects.get(pk=tid)
queue = django_rq.get_queue('low')
job = queue.fetch_job('tf_annotation.create/{}'.format(tid))
if job is not None and (job.is_started or job.is_queued):
raise Exception("The process is already running")
db_labels = db_task.label_set.prefetch_related(
'attributespec_set').all()
db_labels = {db_label.id: db_label.name for db_label in db_labels}
tf_annotation_labels = {
from rules.contrib.views import LoginRequiredMixin, PermissionRequiredMixin
from .models import Book
class BookMixin(object):
def get_object(self):
return Book.objects.get(pk=self.kwargs['book_id'])
class BookMixinWithError(object):
def get_object(self):
raise AttributeError('get_object')
@permission_required('testapp.change_book', fn=objectgetter(Book, 'book_id'))
def change_book(request, book_id):
return HttpResponse('OK')
class BookCreateView(LoginRequiredMixin, PermissionRequiredMixin, BookMixin, CreateView):
fields = ['title']
template_name = 'empty.html'
permission_required = 'testapp.create_book'
class BookUpdateView(LoginRequiredMixin, PermissionRequiredMixin, BookMixin, UpdateView):
fields = ['title']
template_name = 'empty.html'
permission_required = 'testapp.change_book'
class MaquinaUpdateView(PermissionRequiredMixin, SuccessMessageMixin,
UpdateView):
model = Maquina
form_class = EditMaquinaForm
template_name = 'maquinas/maquina_create_edit.html'
permission_required = 'maquina.can_manage'
success_message = 'Máquina atualizada com sucesso!'
def get_success_url(self):
return reverse('registro:maquinas')
@permission_required('maquina.can_manage', fn=objectgetter(Maquina, 'pk'))
def maquina_remove(request, pk):
maquina = get_object_or_404(Maquina, pk=pk)
try:
maquina.delete()
messages.info(request, 'Máquina excluída com sucesso!')
except ProtectedError:
messages.error(
request,
'Essa máquina não pode ser removida! Existem registros associados.'
)
return redirect('registro:maquinas')
import django_rq
import json
import rq
def _create_thread(jid, data):
job = rq.get_current_job()
reid_obj = ReID(jid, data)
job.meta["result"] = json.dumps(reid_obj.run())
job.save_meta()
@login_required
@permission_required(perm=["engine.job.change"],
fn=objectgetter(Job, 'jid'),
raise_exception=True)
def start(request, jid):
try:
data = json.loads(request.body.decode('utf-8'))
queue = django_rq.get_queue("low")
job_id = "reid.create.{}".format(jid)
job = queue.fetch_job(job_id)
if job is not None and (job.is_started or job.is_queued):
raise Exception('ReID process has been already started')
queue.enqueue_call(func=_create_thread,
args=(jid, data),
job_id=job_id,
timeout=7200)
job = queue.fetch_job(job_id)
job.meta = {}
"gameform": GameForm(instance=game, auto_id="id_%s_" + uuid.uuid4().hex),
"bookingform": BookingForm(
initial={"game": game}, auto_id="id_%s_" + uuid.uuid4().hex
),
},
request=request,
)
return {
"form_html": form_html,
"game_html": game_html,
"nav_html": _get_nav_html(game, request),
"order": _get_game_order(game),
}
@permission_required("booking.change_game", fn=objectgetter(Game, "game_id"))
def move_game(request, game_id, direction):
game = get_object_or_404(Game, pk=game_id)
if direction not in ["up", "down", None]:
return HttpResponseBadRequest("Unknown direction")
if direction == "up":
game.up()
elif direction == "down":
game.down()
return JsonResponse({"success": True, **_get_game_response(game, request)})
@permission_required("booking.change_game", fn=objectgetter(Game, "game_id"))
from django.contrib.auth.decorators import login_required
from django.http import HttpResponseRedirect
from django.shortcuts import get_object_or_404, render
from django.urls import reverse
from rules.contrib.views import permission_required, objectgetter
from main.models import Competition, Organisation, Stage
from ..forms.competition import CreateCompetitionForm
@login_required
@permission_required('main.create_competition',
fn=objectgetter(Organisation,
attr_name='org_slug',
field_name='slug'))
def create_competition(request, org_slug):
org = get_object_or_404(Organisation, slug=org_slug)
if request.method == 'POST':
form = CreateCompetitionForm(request.POST)
if form.is_valid():
comp = org.competition_set.create(name=form.cleaned_data['name'],
date=form.cleaned_data['date'])
return HttpResponseRedirect(
reverse('ui/manage_competition', args=[org_slug, comp.id]))
else:
form = CreateCompetitionForm()
return render(request, 'ui/competition/create.html', {'form': form})
def list_competitions(request, org_slug):
from rules.contrib.views import permission_required, objectgetter
from django.views.decorators.gzip import gzip_page
from sendfile import sendfile
from . import annotation, task, models
from cvat.settings.base import JS_3RDPARTY
from cvat.apps.authentication.decorators import login_required
from requests.exceptions import RequestException
import logging
from .log import slogger, clogger
from cvat.apps.engine.models import StatusChoice
############################# High Level server API
@login_required
@permission_required(perm=['engine.job.access'],
fn=objectgetter(models.Job, 'jid'), raise_exception=True)
def catch_client_exception(request, jid):
data = json.loads(request.body.decode('utf-8'))
for event in data['exceptions']:
clogger.job[jid].error(json.dumps(event))
return HttpResponse()
@login_required
def dispatch_request(request):
"""An entry point to dispatch legacy requests"""
if request.method == 'GET' and 'id' in request.GET:
return render(request, 'engine/annotation.html', {
'js_3rdparty': JS_3RDPARTY.get('engine', []),
'status_list': [str(i) for i in StatusChoice]
})
if grade_float >= 90:
return GRADE_A
elif grade_float >=80:
return GRADE_B
elif grade_float >=70:
return GRADE_C
else:
return GRADE_LOW
def get_home_template(request):
return render(request, 'frontend/index.html')
@permission_required('dashboard.get_course_info',
fn=objectgetter(Course, 'course_id', 'canvas_id'), raise_exception=True)
def get_course_info(request, course_id=0):
"""Returns JSON data about a course
:param request: HTTP Request
:type request: Request
:param course_id: Unizin Course ID, defaults to 0
:param course_id: int, optional
:return: JSON to be used
:rtype: str
"""
course_id = canvas_id_to_incremented_id(course_id)
today = timezone.now()
try:
course = Course.objects.get(id=course_id)
return HttpResponse(
"Pools must have an add fencers stage somewhere before them")
elif state == Stage.READY:
pools = pool.pool_set.all()
return render(request, 'ui/stages/pool/READY.html', {
'pools': pools,
'stage_id': pool.stage.id
})
elif state == Stage.STARTED:
pools = pool.pool_set.all()
all_completed = all(map(lambda x: x.complete(), pools))
return render(request, 'ui/stages/pool/STARTED.html', {
'stage': pool.stage,
'pools': pools,
'all_completed': all_completed
})
else:
pools = pool.pool_set.all().order_by('number')
return render(request, 'ui/stages/pool/FINISHED.html', {
'stage': pool.stage,
'pools': pools
})
@login_required
@permission_required('main.manage_competition',
fn=objectgetter(Pool, 'pool_id'))
def dt_manage_pool(request, pool_id):
return render(request, 'ui/stages/pool/dt_pool_edit.html',
{'pool_id': pool_id})
from continuing_education.models.prospect import Prospect
from continuing_education.views.common import get_object_list
@login_required
@permission_required('continuing_education.view_prospect',
raise_exception=True)
def list_prospects(request):
prospects_list = get_prospects_by_user(request.user)
return render(
request, "prospects.html", {
'prospects': get_object_list(request, prospects_list),
'prospects_count': len(prospects_list)
})
@login_required
@permission_required('continuing_education.view_prospect',
fn=objectgetter(Prospect, 'prospect_id'),
raise_exception=True)
def prospect_details(request, prospect_id):
prospect = get_object_or_404(Prospect, pk=prospect_id)
return render(request, "prospect_details.html", {'prospect': prospect})
@login_required
@permission_required('continuing_education.export_prospect',
raise_exception=True)
def prospect_xls(request):
return create_xls(request.user)