def copy_object(request): """ Add object uid or file path to sessions clipboard. """ object_uid = request.POST.get('uid', '') project_uid = request.POST.get('project_uid', '') clipboard = request.POST.get('clipboard') project = Project.objects.filter(uid=project_uid).first() if not project: return ajax_error("Project does not exist.") is_readable = auth.is_readable(user=request.user, project=project) if not is_readable: return ajax_error('You do not have access to copy this object.') # Return current clipboard contents copied_uids = auth.copy_uid(request=request, uid=object_uid, board=clipboard) return ajax_success( f"Copied. Clipboard contains :{len(copied_uids)} objects.")
def copy_file(request): """ Add file from import root directory into clipboard. """ # Assumes incoming path is a full path path = request.POST.get('path') user = request.user # Project uid to check access uid = request.POST.get('uid') or 0 project = Project.objects.filter(id=uid).first() if uid and not project: return ajax_error(msg="Project does not exist.") if project and not auth.is_readable(user=user, obj=project): return ajax_error(msg="You do not have access to copy this file") if not os.path.exists(path): return ajax_error(msg="File path does not exist.") if path.startswith(settings.IMPORT_ROOT_DIR) and not user.profile.trusted: return ajax_error( msg="Only trusted users can copy from this directory.") copied = auth.copy_file(request=request, fullpath=path) return ajax_success(msg=f"{len(copied)} files copied.")
def copy_object(request): """ Add object uid or file path to sessions clipboard. """ # Map the query parameter to a clipboard and database model. mapper = { "data": (Data, COPIED_DATA), "job": (Job, COPIED_RESULTS), "recipe": (Analysis, COPIED_RECIPES) } uid = request.POST.get('uid', '') # Get the clipboard to copy to clipboard = request.POST.get(settings.CLIPBOARD_NAME) klass, board = mapper.get(clipboard, (None, None)) if not (klass and board): return ajax_error("Object or board does not exist.") obj = klass.objects.filter(uid=uid).first() is_readable = auth.is_readable(user=request.user, obj=obj) if not is_readable: return ajax_error('You do not have access to copy this object.') # Return current clipboard contents copied = auth.copy_uid(request=request, uid=uid, board=board) return ajax_success(f"Copied. Clipboard contains :{len(copied)} objects.")
def ajax_clipboard(request): """ Displays the most recent object in clipboard. """ # Get the most current item in the clipboard. pid = request.POST.get("id", 0) user = request.user project = Project.objects.filter(id=pid).first() board = auth.recent_clipboard(request=request) key, vals = board count = len(vals) if project and auth.is_readable(user=user, obj=project) and count: # Load items into clipboard tmpl = loader.get_template('widgets/clipboard.html') movable = key in [COPIED_RECIPES, COPIED_DATA] context = dict(count=count, board=key, is_recipe=key == COPIED_RECIPES, movable=movable) template = tmpl.render(context=context) else: template = '' return ajax_success(html=template, msg="Refreshed clipboard")
def job_rerun(request, uid): # Get the job. job = Job.objects.filter(uid=uid).first() next = request.GET.get('next') # Get the recipe recipe = job.analysis # Get the job JSON json_data = job.json_data # Validate users can run the recipe. valid, msg = auth.validate_recipe_run(user=request.user, recipe=recipe) if not valid: messages.error(request, msg) redir = next or reverse('job_view', kwargs=dict(uid=job.uid)) return redirect(redir) # Create a new job job = auth.create_job(analysis=recipe, user=request.user, json_data=json_data) # Spool via UWSGI or run it synchronously. tasks.execute_job.spool(job_id=job.id) if auth.is_readable(user=request.user, obj=recipe): url = reverse('recipe_view', kwargs=dict(uid=job.analysis.uid)) + "#results" else: url = job.url() return redirect(url)
def get_part(request, name, id): """ Return a template by name and with uid rendering """ user = request.user # The recipe that needs to be edited. recipe = Analysis.objects.filter(id=id).annotate( job_count=Count("job", filter=Q(job__deleted=False))).first() project = recipe.project if not auth.is_readable(project=project, user=user): message = str("Recipe is not writable by current user") return HttpResponse(message) # Fills in project level counts (results, data and recipe counts). counts = get_counts(recipe.project) if name == "run": initial = dict(name=f"Results for: {recipe.name}") form = forms.RecipeInterface(request=request, analysis=recipe, json_data=recipe.json_data, initial=initial) else: # Initial form loading via a GET request. form = forms.RecipeForm(instance=recipe, user=request.user, project=project) remap = dict( info="parts/recipe_info.html", code="parts/recipe_code.html", interface="parts/recipe_interface.html", run="parts/recipe_run.html", results="parts/recipe_results.html", ) name = remap.get(name, "parts/placeholder.html") # Check to see if this recipe is runnable by the user. is_runnable = auth.authorize_run(user=user, recipe=recipe) # Get the list of jobs required for recipe results jobs = recipe.job_set.filter( deleted=False).order_by("-lastedit_date").all() context = dict(recipe=recipe, form=form, is_runnable=is_runnable, job_list=jobs, rerun_btn=False) context.update(counts) html = render(request, name, context=context) return html
def security_label(context, analysis): user = context['request'].user if user.is_anonymous: is_readable = False else: is_readable = auth.is_readable(user=user, project=analysis.project) context.update(dict(recipe=analysis, is_readable=is_readable)) return context
def clipboard(context, project_uid): request = context['request'] user = request.user project = Project.objects.filter(uid=project_uid).first() board = auth.recent_clipboard(request=request) key, vals = board board_count = len(vals) movable = key in [const.COPIED_RECIPES, const.COPIED_DATA] if project and auth.is_readable(user=user, obj=project) and board_count: # Load items into clipboard context = dict(count=board_count, board=key, is_recipe=key == const.COPIED_RECIPES, movable=movable) else: context = dict() return context