def search(request):
results = dict(analysis=[], project=[], data=[], job=[])
# Search each model type by title, text, owner email/name.
search_fields = ['name', 'text', 'owner__email', 'owner__profile__name']
# Get the objects the user can access
projects = get_project_list(user=request.user)
model_map = {
"job": Job.objects.filter(project__in=projects),
"analysis": Analysis.objects.filter(project__in=projects),
"data": Data.objects.filter(project__in=projects),
"project": projects
}
# Create a search form for each model type.
for mtype in results:
queryset = model_map[mtype]
# Load query from GET request.
search_form = SearchForm(queryset=queryset,
search_fields=search_fields,
data=request.GET or {})
# Add search results to dict
if search_form.is_valid():
results[mtype] = search_form.get_queryset()
return results
def __init__(self, root, cmd_channel, current_user=None):
"""
- (str) root: the user "real" home directory (e.g. '/home/user')
- (instance) cmd_channel: the FTPHandler class instance
- (str) current_user: username of currently logged in user
"""
# Set initial current working directory.
# By default initial cwd is set to "/" to emulate a chroot jail.
# If a different behavior is desired (e.g. initial cwd = root,
# to reflect the real filesystem) users overriding this class
# are responsible to set _cwd attribute as necessary.
#self._cwd = root
self._cwd = root
self._root = root
self.cmd_channel = cmd_channel
logger.info(f"current_user={current_user}")
# Get current user info
self.user_table = self.cmd_channel.authorizer.user_table
self.user = self.user_table.get(current_user) or dict(
user=AnonymousUser)
self.project_list = auth.get_project_list(user=self.user["user"])
super(BiostarFileSystem, self).__init__(root, cmd_channel)
def get_projects(user):
"Used to return projects list in the profile."
projects = auth.get_project_list(user=user, include_public=False)
access = Access.objects.filter(project__in=projects, user=user,
access__gt=Access.NO_ACCESS)
return [(access, access.project) for access in access]
def search(request):
projects = auth.get_project_list(user=request.user)
data = Data.objects.filter(deleted=False,project__in=projects)
recipe = Analysis.objects.filter(deleted=False, project__in=projects)
jobs = Job.objects.filter(deleted=False, project__in=projects)
projects = projects.filter(deleted=False)
content = [dict(name="Projects",results =update_dict(iter=projects)),
dict(name="Data", results=update_dict(iter=data)),
dict(name="Recipes", results=update_dict(iter=recipe)),
dict(name="Jobs", results=update_dict(iter=jobs)),
]
return dict(content=json.dumps(content))
def list_projects(context, target):
user = context["request"].user
projects = auth.get_project_list(user=target)
# Don't show private projects non owners
if user != target:
projects = projects.exclude(privacy=Project.PRIVATE)
projects = projects.annotate(data_count=Count('data', distinct=True, filter=Q(deleted=False)),
job_count=Count('job', distinct=True, filter=Q(deleted=False)),
recipe_count=Count('analysis', distinct=True, filter=Q(deleted=False)),
)
projects = projects.order_by("-rank", "-lastedit_date")
return dict(projects=projects)
def __init__(self, root, cmd_channel, current_user=None):
"""
- (str) root: the user "real" home directory (e.g. '/home/user')
- (instance) cmd_channel: the FTPHandler class instance
- (str) current_user: username of currently logged in user. Used to key user_table.
"""
# Set initial current working directory.
# By default initial cwd is set to "/" to emulate a chroot jail.
# If a different behavior is desired (e.g. initial cwd = root,
# to reflect the real filesystem) users overriding this class
# are responsible to set _cwd attribute as necessary.
self._cwd = root
self._root = root
self.cmd_channel = cmd_channel
self.timefunc = time.localtime if cmd_channel.use_gmt_times else time.gmtime
logger.info(f"current_user={current_user}")
# Dict with all users stored by parent class
self.user_table = self.cmd_channel.authorizer.user_table
# Logged in user
self.username = current_user
self.user = self.user_table.get(current_user) or dict(
user=AnonymousUser)
# Projects the user has access to
self.projects = auth.get_project_list(user=self.user["user"])
# Data and results in project
self.data = Data.objects.filter(deleted=False,
project__in=self.projects,
state__in=(Data.READY, Data.PENDING))
self.jobs = Job.objects.filter(deleted=False,
project__in=self.projects)
# Get authorizer to set write permission on directories.
self.authorizer = self.cmd_channel.authorizer
super(BiostarFileSystem, self).__init__(root, cmd_channel)
def make_project_dir(self, root_project, path):
"""
Create a project in the database and refresh the
projects tab in the FTP server so it shows up as a directory.
"""
user = self.fs.user["user"]
if self.fs.projects.filter(name=root_project):
self.respond('550 Directory already exists.')
return
# Create a new project
auth.create_project(user=user, name=root_project)
# Refresh projects tab
self.fs.projects = auth.get_project_list(user=user)
line = self.fs.fs2ftp(path)
self.respond('257 "%s" directory created.' % line.replace('"', '""'))
logger.info(f"path={path}")
return path
def user_profile(request, uid):
profile = Profile.objects.filter(uid=uid).first()
if not profile:
messages.error(request, "User does not exist")
return redirect("/")
# Get the active tab, defaults to project
active_tab = request.GET.get(ACTIVE_TAB, POSTS)
# User viewing profile is a moderator
can_moderate = profile.can_moderate(source=request.user)
if active_tab == PROJECT:
objs = get_project_list(user=profile.user, include_public=False)
objs = annotate_projects(objs)
objs = objs.exclude(
privacy=Project.PRIVATE) if request.user != profile.user else objs
objs = objs.order_by("rank", "-date")
else:
objs = my_posts(target=profile.user, request=request)
objs = objs.prefetch_related("root", "lastedit_user__profile",
"thread_users__profile")
objs = objs.order_by("rank", '-lastedit_date')
page = request.GET.get("page", 1)
paginator = Paginator(objs, per_page=20)
page = page if page is not None else 1
objs = paginator.get_page(page)
context = dict(user=profile.user,
objs=objs,
active=active_tab,
const_post=POSTS,
const_project=PROJECT,
can_moderate=can_moderate)
return render(request, settings.PROFILE_TEMPLTE, context)
def user_profile(request, uid):
profile = Profile.objects.filter(uid=uid).first()
if not profile:
messages.error(request, "User does not exist")
return redirect("/")
# Get the active tab, defaults to project
active_tab = request.GET.get(ACTIVE_TAB, POSTS)
can_moderate = profile.can_moderate(source=request.user)
objs = get_project_list(user=profile.user, include_public=False)
if request.user != profile.user:
objs = objs.exclude(privacy=Project.PRIVATE)
objs = objs.order_by("-date")
page = request.GET.get("page", 1)
paginator = Paginator(objs, per_page=20)
page = page if page is not None else 1
objs = paginator.get_page(page)
context = dict(user=profile.user,
objs=objs,
const_name=ACTIVE_TAB,
const_post=POSTS,
const_project=PROJECT,
const_recipes=RECIPES,
can_moderate=can_moderate)
context.update({active_tab: ACTIVE_TAB})
return render(request, 'accounts/user_profile.html', context)
def project_list(user):
# Maintain same order as views (doesn't really show)
projects = auth.get_project_list(user=user).order_by("-sticky", "-privacy")
projects = projects.order_by("-privacy", "-sticky", "-date", "-id")
return [p.name for p in projects]
