def category(request, template_name="projects/category.html"):
query = request.GET.get('q', None)
if get_setting('site', 'global', 'searchindex') and query:
projects = Project.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'projects.search')
projects = Project.objects.filter(filters).distinct()
categories = Category.objects.all()
category_id = request.GET.get('category', None)
if category_id:
try:
category = Category.objects.get(pk=category_id)
except:
category = None
if category:
projects = projects.filter(category=category)
log_defaults = {
'event_id' : 1180400,
'event_data': '%s searched by %s' % ('Project', request.user),
'description': '%s searched' % 'Project',
'user': request.user,
'request': request,
'source': 'projects'
}
EventLog.objects.log(**log_defaults)
return render_to_response(template_name, {'projects':projects, 'categories': categories
},
context_instance=RequestContext(request))
def __init__(self, *args, **kwargs):
super(FileForm, self).__init__(*args, **kwargs)
default_groups = Group.objects.filter(status=True, status_detail="active")
if args:
post_data = args[0]
else:
post_data = None
if self.user and not self.user.profile.is_superuser:
filters = get_query_filters(self.user, 'user_groups.view_group', **{'perms_field': False})
groups = default_groups.filter(filters).distinct()
groups_list = list(groups.values_list('pk', 'name'))
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
else:
groups_list = default_groups.values_list('pk', 'name')
self.fields['group'].choices = groups_list
if self.instance and self.instance.pk:
self.fields['file_sub_cat'].queryset = FilesCategory.objects.filter(
parent=self.instance.file_cat)
if post_data:
file_cat = post_data.get('file_cat', '0')
if file_cat and file_cat != '0' and file_cat != u'':
file_cat = FilesCategory.objects.get(pk=int(file_cat))
self.fields['file_sub_cat'].queryset = FilesCategory.objects.filter(parent=file_cat)
if 'file' in self.fields:
self.fields['file'].validators = [FileValidator()]
def __init__(self, *args, **kwargs):
super(ArticleForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields['body'].widget.mce_attrs['app_instance_id'] = self.instance.pk
else:
self.fields['body'].widget.mce_attrs['app_instance_id'] = 0
self.fields['group'].initial = Group.objects.get_initial_group_id()
default_groups = Group.objects.filter(status=True, status_detail="active")
if self.user and not self.user.profile.is_superuser:
if 'status_detail' in self.fields:
self.fields.pop('status_detail')
filters = get_query_filters(self.user, 'user_groups.view_group', **{'perms_field': False})
groups = default_groups.filter(filters).distinct()
groups_list = list(groups.values_list('pk', 'name'))
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
else:
groups_list = default_groups.values_list('pk', 'name')
self.fields['group'].choices = groups_list
self.fields['google_profile'].help_text = mark_safe(GOOGLE_PLUS_HELP_TEXT)
self.fields['timezone'].initial = settings.TIME_ZONE
def filter_categories(self, user, qs):
""" return a queryset with categories `user` is allowed to see """
if not user.is_staff:
filters = get_query_filters(user, 'forums.view_category')
qs = qs.filter(Q(hidden=False) & filters).distinct()
return qs
def detail(request, slug, template_name="committees/detail.html"):
committee = get_object_or_404(Committee, slug=slug)
if has_perm(request.user, 'committees.view_committee', committee):
EventLog.objects.log(instance=committee)
officers = committee.officers()
#has_group_view_permission is True if there is at least one
#group where the user is a member that has a view_committee permission.
has_group_view_permission = False
#Check user for group view permissions
if request.user.is_authenticated():
groups = request.user.group_set.all()
perms = has_groups_perms(committee).filter(group__in=groups)
for perm in perms:
#Check if permission has view committee permission
has_group_view_permission |= perm.codename == 'view_committee'
if has_group_view_permission:
break
filters = get_query_filters(request.user, 'files.view_file')
files = File.objects.filter(filters).filter(group=committee.group).distinct()
return render_to_response(template_name,
{
'committee': committee,
'officers': officers,
'files': files,
'has_group_view_permission': has_group_view_permission,
},
context_instance=RequestContext(request))
else:
raise Http403
def __init__(self, *args, **kwargs):
mts = kwargs.pop('mts')
self.user = kwargs.pop('user')
super(ProfileSearchForm, self).__init__(*args, **kwargs)
self.fields['first_name'].widget.attrs.update({'placeholder': _('Exact Match Search')})
self.fields['last_name'].widget.attrs.update({'placeholder': _('Exact Match Search')})
self.fields['email'].widget.attrs.update({'placeholder': _('Exact Match Search')})
if not mts:
del self.fields['membership_type']
del self.fields['member_only']
else:
choices = [(0, _('SELECT ONE'))]
choices += [(mt.id, mt.name) for mt in mts]
self.fields['membership_type'].widget = forms.widgets.Select(
choices=choices)
# group choices
filters = get_query_filters(self.user, 'user_groups.view_group', **{'perms_field': False})
group_choices = [(0, _('SELECT ONE'))] + list(Group.objects.filter(
status=True, status_detail="active"
).filter(filters).distinct().order_by('name'
).values_list('pk', 'name'))
self.fields['group'].widget = forms.widgets.Select(
choices=group_choices)
def navigation(context, nav_id):
"""
Renders the nav and its nav items.
This will call nav_item that will call itself recursively nesting
the subnavs
"""
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
nav_id = Variable(nav_id)
nav_id = nav_id.resolve(context)
except:
pass
try:
filters = get_query_filters(user, 'navs.view_nav')
navs = Nav.objects.filter(filters).filter(id=nav_id)
if user.is_authenticated():
if not user.profile.is_superuser:
navs = navs.distinct()
nav = navs[0]
except:
return None
context.update({
"nav": nav,
"items": nav.top_items,
})
return context
def render(self, context):
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
pk = Variable(self.pk)
pk = pk.resolve(context)
except:
pk = self.pk
try:
filters = get_query_filters(user, 'navs.view_nav')
nav = Nav.objects.filter(filters).filter(pk=pk)
if user.is_authenticated():
if not user.profile.is_superuser:
nav = nav.distinct()
context[self.context_var] = nav[0]
except:
pass
return unicode()
def __init__(self, *args, **kwargs):
super(StoryForm, self).__init__(*args, **kwargs)
if self.instance.image:
self.fields["photo_upload"].help_text = (
'<input name="remove_photo" id="id_remove_photo" type="checkbox"/> Remove current image: <a target="_blank" href="/files/%s/">%s</a>'
% (self.instance.image.pk, basename(self.instance.image.file.name))
)
else:
self.fields.pop("remove_photo")
default_groups = Group.objects.filter(status=True, status_detail="active")
if self.user and not self.user.profile.is_superuser:
if "status_detail" in self.fields:
self.fields.pop("status_detail")
filters = get_query_filters(self.user, "user_groups.view_group", **{"perms_field": False})
groups = default_groups.filter(filters).distinct()
groups_list = list(groups.values_list("pk", "name"))
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
else:
groups_list = default_groups.values_list("pk", "name")
self.fields["group"].choices = groups_list
def search(request, template_name="user_groups/search.html"):
"""
This page lists out all user groups. If a search index
is available, this page also allows you to search through
user groups.
"""
query = request.GET.get('q', None)
form = GroupSearchForm(request.GET)
cat = None
filters = get_query_filters(request.user, 'groups.view_group', perms_field=False)
groups = Group.objects.filter(filters).distinct()
if request.user.is_authenticated():
groups = groups.select_related()
if form.is_valid():
cat = form.cleaned_data['search_category']
if query and cat:
groups = groups.filter(**{cat: query} )
groups = groups.order_by('slug')
EventLog.objects.log()
return render_to_response(template_name, {'groups':groups, 'form': form},
context_instance=RequestContext(request))
def render(self, context):
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
pk = Variable(self.pk)
pk = pk.resolve(context)
except:
pk = self.pk
try:
filters = get_query_filters(user, 'boxes.view_box')
box = Box.objects.filter(filters).filter(pk=pk)
if user.is_authenticated():
if not user.profile.is_superuser:
box = box.distinct()
context['box'] = box[0]
template = get_template('boxes/edit-link.html')
output = '<div id="box-%s" class="boxes">%s %s</div>' % (
box[0].pk,
box[0].content,
template.render(context),
)
return output
except:
return unicode()
def search(request, template_name="news/search.html"):
query = request.GET.get('q', None)
form = NewsSearchForm(request.GET)
if form.is_valid():
try:
news_group = int(form.cleaned_data.get('news_group', None))
except:
news_group = None
if get_setting('site', 'global', 'searchindex') and query:
news = News.objects.search(query, user=request.user)
# use order (existing for all modules) for sorting cause the current
# haystack + whoosh cannot sort by release_dt correctly
news = news.order_by('-order')
else:
filters = get_query_filters(request.user, 'news.view_news')
news = News.objects.filter(filters).distinct()
news = news.order_by('-release_dt')
if news_group:
news = news.filter(groups__in=[news_group])
if not has_perm(request.user, 'news.view_news'):
news = news.filter(release_dt_local__lte=datetime.now())
EventLog.objects.log()
return render_to_response(template_name, {'search_news': news,
'form': form},
context_instance=RequestContext(request))
def __init__(self, *args, **kwargs):
if 'user' in kwargs:
self.user = kwargs.pop('user', None)
else:
self.user = None
data = args[0] if args else kwargs['data'] if 'data' in kwargs else None
category = data['file_cat'] if data and 'file_cat' in data else None
super(FileSearchForm, self).__init__(*args, **kwargs)
user = self.user or AnonymousUser()
filters = get_query_filters(user, 'user_groups.view_group', **{'perms_field': False})
groups = Group.objects.filter(filters).distinct()
groups_list = [[g.id, g.name] for g in groups]
if user.is_authenticated:
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
groups_list.insert(0, ['', '------------'])
self.fields['group'].choices = tuple(groups_list)
# Update categories and subcategories choices
main_categories = FilesCategory.objects.filter(parent__isnull=True)
self.fields['file_cat'].queryset = main_categories
if category:
sub_categories = FilesCategory.objects.filter(parent=category)
self.fields['file_sub_cat'].empty_label = "-----------"
self.fields['file_sub_cat'].queryset = sub_categories
def nearest(request, template_name="locations/nearest.html"):
locations = []
lat, lng = None, None
query = request.GET.get('q')
filters = get_query_filters(request.user, 'locations.view_location')
if query:
lat, lng = get_coordinates(address=query)
all_locations = Location.objects.filter(filters).distinct()
if not request.user.is_anonymous:
all_locations = all_locations.select_related()
if all((lat,lng)):
for location in all_locations:
location.distance = location.get_distance2(lat, lng)
if location.distance is not None:
locations.append(location)
locations.sort(key=lambda x: x.distance)
EventLog.objects.log()
return render_to_resp(request=request, template_name=template_name, context={
'locations':locations,
'origin': {'lat':lat,'lng':lng},
})
def __init__(self, *args, **kwargs):
super(NewsForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields['body'].widget.mce_attrs['app_instance_id'] = self.instance.pk
else:
self.fields['body'].widget.mce_attrs['app_instance_id'] = 0
self.fields['group'].initial = Group.objects.get_initial_group_id()
default_groups = Group.objects.filter(status=True, status_detail="active")
#if not self.user.profile.is_superuser:
if self.user and not self.user.profile.is_superuser:
if 'status_detail' in self.fields:
self.fields.pop('status_detail')
filters = get_query_filters(self.user, 'user_groups.view_group', **{'perms_field': False})
groups = default_groups.filter(filters).distinct()
groups_list = list(groups.values_list('pk', 'name'))
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
else:
groups_list = default_groups.values_list('pk', 'name')
self.fields['group'].choices = groups_list
self.fields['google_profile'].help_text = mark_safe(GOOGLE_PLUS_HELP_TEXT)
self.fields['timezone'].initial = settings.TIME_ZONE
# only show the remove photo checkbox if there is already a thumbnail
if self.instance.thumbnail:
self.fields['photo_upload'].help_text = '<input name="remove_photo" id="id_remove_photo" type="checkbox"/> Remove current image: <a target="_blank" href="/files/%s/">%s</a>' % (self.instance.thumbnail.pk, basename(self.instance.thumbnail.file.name))
else:
self.fields.pop('remove_photo')
def tinymce_fb(request, template_name="files/templates/tinymce_fb.html"):
"""
Get a list of files (images) for tinymce file browser.
"""
query = u''
try:
page_num = int(request.GET.get('page', 1))
except:
page_num = 1
form = FileSearchMinForm(request.GET)
if form.is_valid():
query = form.cleaned_data.get('q', '')
filters = get_query_filters(request.user, 'files.view_file')
files = File.objects.filter(filters).distinct().order_by('-create_dt')
type = request.GET.get('type', '')
if type == 'image':
files = files.filter(f_type='image')
elif type == 'media':
files = files.filter(f_type='video')
if query:
files = files.filter(Q(file__icontains=query)|
Q(name__icontains=query))
paginator = Paginator(files, 10)
files = paginator.page(page_num)
return render_to_response(
template_name, {
"files": files,
'page_num': page_num,
'page_range': paginator.page_range,
'csrf_token': csrf_get_token(request),
'can_upload_file': has_perm(request.user, 'files.add_file')
}, context_instance=RequestContext(request))
def search(request, template_name="resumes/search.html"):
"""
This page lists out all resumes from newest to oldest.
If a search index is available, this page will also
have the option to search through resumes.
"""
has_index = get_setting('site', 'global', 'searchindex')
query = request.GET.get('q', None)
if has_index and query:
resumes = Resume.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'resumes.view_resume')
resumes = Resume.objects.filter(filters).distinct()
if request.user.is_authenticated():
resumes = resumes.select_related()
resumes = resumes.order_by('-create_dt')
EventLog.objects.log(**{
'event_id' : 354000,
'event_data': '%s searched by %s' % ('Resume', request.user),
'description': '%s searched' % 'Resume',
'user': request.user,
'request': request,
'source': 'resumes'
})
return render_to_response(template_name, {'resumes':resumes},
context_instance=RequestContext(request))
def __init__(self, *args, **kwargs):
user = kwargs.pop('user', None)
super(NewsSearchForm, self).__init__(*args, **kwargs)
group_filters = get_query_filters(user, 'groups.view_group', perms_field=False)
group_choices = Group.objects.filter(group_filters).distinct(
).order_by('name').values_list('id', 'name')
self.fields['news_group'].choices = [('','All')] + list(group_choices)
def search(request, template_name="entities/search.html"):
filters = get_query_filters(request.user, 'entities.view_entity')
entities = Entity.objects.filter(filters).distinct()
EventLog.objects.log()
return render_to_resp(request=request, template_name=template_name,
context={'entities':entities})
def search(request, template_name="entities/search.html"):
filters = get_query_filters(request.user, 'entities.view_entity')
entities = Entity.objects.filter(filters).distinct()
EventLog.objects.log()
return render_to_response(template_name, {'entities':entities},
context_instance=RequestContext(request))
def render(self, context):
request = context.get('request', None)
# make sure data in query and cat are valid
form = EventSimpleSearchForm(request.GET)
if form.is_valid():
cat = form.cleaned_data.get('search_category', None)
query = form.cleaned_data.get('q', None)
else:
cat = None
query = ''
day = self.day.resolve(context)
type_slug = self.type_slug.resolve(context)
types = Type.objects.filter(slug=type_slug)
type = None
if types:
type = types[0]
day = datetime(day.year, day.month, day.day)
weekday = day.strftime('%a')
#one day offset so we can get all the events on that day
bound = timedelta(hours=23, minutes=59)
start_dt = day+bound
end_dt = day
filters = get_query_filters(context['user'], 'events.view_event')
events = Event.objects.filter(filters).filter(start_dt__lte=start_dt, end_dt__gte=end_dt).distinct().extra(select={'hour': 'extract( hour from start_dt )'}).extra(select={'minute': 'extract( minute from start_dt )'})
events = events.filter(enable_private_slug=False)
if type:
events = events.filter(type=type)
if weekday == 'Sun' or weekday == 'Sat':
events = events.filter(on_weekend=True)
if self.ordering == "single_day":
events = events.order_by('-priority', 'hour', 'minute')
else:
if self.ordering:
events = events.order_by(self.ordering)
else:
events = events.order_by('-priority', 'start_dt')
if cat == 'priority':
events = events.filter(**{cat : True })
elif query and cat:
events = events.filter(**{cat : query})
context[self.context_var] = events
return ''
def search(request, template_name="directories/search.html"):
filters = get_query_filters(request.user, 'directories.view_directory')
directories = Directory.objects.filter(filters).distinct()
cat = None
category = None
sub_category = None
if not request.user.is_anonymous():
directories = directories.select_related()
query = request.GET.get('q', None)
# Handle legacy tag links
if query and "tag:" in query:
return HttpResponseRedirect("%s?q=%s&search_category=tags__icontains" %(reverse('directories'), query.replace('tag:', '')))
form = DirectorySearchForm(request.GET, is_superuser=request.user.is_superuser)
if form.is_valid():
cat = form.cleaned_data['search_category']
category = form.cleaned_data['category']
sub_category = form.cleaned_data['sub_category']
search_method = form.cleaned_data['search_method']
if query and cat:
search_type = '__iexact'
if search_method == 'starts_with':
search_type = '__istartswith'
elif search_method == 'contains':
search_type = '__icontains'
search_filter = {'%s%s' % (cat, search_type): query}
directories = directories.filter( **search_filter)
if category:
directories = directories.filter(categories__category__id=category)
if sub_category:
directories = directories.filter(categories__parent__id=sub_category)
directories = directories.order_by('headline')
EventLog.objects.log()
try:
category = int(category)
except:
category = 0
categories, sub_categories = Directory.objects.get_categories(category=category)
return render_to_response(template_name,
{'directories': directories,
'categories': categories,
'form' : form,
'sub_categories': sub_categories,
'a_to_z': string.lowercase[:26]},
context_instance=RequestContext(request))
def emergency_announcement(context, user):
filters = get_query_filters(user, 'announcements.view_emergencyannouncement')
announcements = EmergencyAnnouncement.objects.filter(filters).distinct()
announcements = announcements.filter(enabled=True).order_by('-create_dt')
context.update({
"user": user,
"announcements": announcements
})
return context
def topic(request, id, template_name="help_files/topic.html"):
""" List of topic help files """
topic = get_object_or_404(Topic, pk=id)
filters = get_query_filters(request.user, 'help_files.view_helpfile')
help_files = HelpFile.objects.filter(filters).filter(topics__in=[topic.pk]).distinct()
if not request.user.is_anonymous:
help_files = help_files.select_related()
EventLog.objects.log(instance=topic)
return render_to_resp(request=request, template_name=template_name,
context={'topic':topic, 'help_files':help_files})
def search(request, template_name="committees/search.html"):
query = request.GET.get('q', None)
if query:
committees = Committee.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'committees.view_committee')
committees = Committee.objects.filter(filters).distinct()
committees = committees.order_by('-create_dt')
EventLog.objects.log()
return render_to_response(template_name, {'committees': committees},
context_instance=RequestContext(request))
def search(request, template_name="studygroups/search.html"):
query = request.GET.get('q', None)
if query:
studygroups = StudyGroup.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'studygroups.view_studygroup')
studygroups = StudyGroup.objects.filter(filters).distinct()
studygroups = studygroups.order_by('-create_dt')
EventLog.objects.log()
return render_to_response(template_name, {'studygroups': studygroups},
context_instance=RequestContext(request))
def search(request, template_name="files/search.html"):
"""
This page lists out all files from newest to oldest.
If a search index is available, this page will also
have the option to search through files.
"""
query = u''
category = None
sub_category = None
group = None
form = FileSearchForm(request.GET, **{'user': request.user})
if form.is_valid():
query = form.cleaned_data.get('q', '')
category = form.cleaned_data.get('file_cat', None)
sub_category = form.cleaned_data.get('file_sub_cat', None)
group = form.cleaned_data.get('group', None)
filters = get_query_filters(request.user, 'files.view_file')
files = File.objects.filter(filters).distinct()
if query:
files = files.filter(Q(file__icontains=query)|
Q(name__icontains=query)|
Q(description__icontains=query)|
Q(tags__icontains=query))
if category:
files = files.filter(file_cat=category)
if sub_category:
files = files.filter(file_sub_cat=sub_category)
if group:
files = files.filter(group_id=group)
files = files.order_by('-update_dt')
EventLog.objects.log()
layout = get_setting("module", "files", "layout")
base_template_path = "files/base.html"
if layout == 'grid':
base_template_path = "base-wide.html"
return render_to_response(
template_name, {
'files': files,
'form': form,
'layout': layout,
'base_template_path': base_template_path,
}, context_instance=RequestContext(request))
def search(request, template_name="discounts/search.html"):
if not has_perm(request.user, 'discounts.view_discount'):
raise Http403
filters = get_query_filters(request.user, 'discounts.view_discount')
discounts = Discount.objects.filter(filters).distinct()
query = request.GET.get('q', None)
if query:
discounts = discounts.filter(discount_code__icontains=query)
EventLog.objects.log()
return render_to_resp(request=request,
template_name=template_name,
context={'discounts': discounts})
def group_choices(user):
"""
returns a list of (group.pk, group.label) for groups viewable
for the given user.
"""
filters = get_query_filters(user, 'groups.view_group', perms_field=False)
groups = Group.objects.filter(filters).exclude(type="membership").distinct()
if not user.profile.is_superuser:
groups = groups.exclude(allow_self_add=False)
choices = [(group.pk, "%s (%s)" % (group.label, group.name)) for group in groups]
return choices
def search(request, template_name="forms/search.html"):
if not has_perm(request.user, "forms.view_form"):
raise Http403
filters = get_query_filters(request.user, "forms.view_form")
forms = Form.objects.filter(filters).distinct()
query = request.GET.get("q", None)
if query:
forms = forms.filter(Q(title__icontains=query) | Q(intro__icontains=query) | Q(response__icontains=query))
forms = forms.order_by("-pk")
EventLog.objects.log()
return render_to_response(template_name, {"forms": forms}, context_instance=RequestContext(request))
def search(request, template_name="studygroups/search.html"):
query = request.GET.get('q', None)
if query:
studygroups = StudyGroup.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user,
'studygroups.view_studygroup')
studygroups = StudyGroup.objects.filter(filters).distinct()
studygroups = studygroups.order_by('-create_dt')
EventLog.objects.log()
return render_to_response(template_name, {'studygroups': studygroups},
context_instance=RequestContext(request))
def group_choices(user):
"""
returns a list of (group.pk, group.label) for groups viewable
for the given user.
"""
filters = get_query_filters(user, 'groups.view_group', perms_field=False)
groups = Group.objects.filter(filters).exclude(type="membership").distinct()
if not user.profile.is_superuser:
groups = groups.exclude(allow_self_add=False)
choices = [(group.pk, "%s (%s)" % (group.label, group.name)) for group in groups]
return choices
def search(request, template_name="committees/search.html"):
query = request.GET.get('q', None)
if query:
committees = Committee.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'committees.view_committee')
committees = Committee.objects.filter(filters).distinct()
committees = committees.order_by('-create_dt')
EventLog.objects.log()
return render_to_resp(request=request,
template_name=template_name,
context={'committees': committees})
def search(request, template_name="pages/search.html"):
"""
Search pages.
"""
query = request.GET.get('q')
filters = get_query_filters(request.user,
'pages.view_page',
association_id=get_association_id(request))
pages = Page.objects.filter(filters).distinct()
if query:
if "category:" in query or "sub_category:" in query:
# handle category and sub_category
key, name = query.split(':', 1)
categories = Category.objects.filter(name__iexact=name)
if categories.exists():
category = categories[0]
if key == 'category':
page_ids = CategoryItem.objects.filter(
content_type_id=ContentType.objects.get_for_model(
Page),
category_id=category.id,
parent_id__isnull=True).values_list('object_id',
flat=True)
else:
page_ids = CategoryItem.objects.filter(
content_type_id=ContentType.objects.get_for_model(
Page),
parent_id=category.id,
category_id__isnull=True).values_list('object_id',
flat=True)
pages = pages.filter(id__in=page_ids)
else:
pages = Page.objects.none()
else:
pages = pages.filter(
Q(title__icontains=query)
| Q(content__icontains=query)
| Q(slug__icontains=query))
pages = pages.exclude(status_detail='archive')
pages = pages.order_by('-create_dt')
EventLog.objects.log()
return render_to_response(template_name, {'pages': pages},
context_instance=RequestContext(request))
def search(request, template_name="directories/search.html"):
filters = get_query_filters(request.user, 'directories.view_directory')
directories = Directory.objects.filter(filters).distinct()
cat = None
if not request.user.is_anonymous():
directories = directories.select_related()
query = request.GET.get('q', None)
form = DirectorySearchForm(request.GET,
is_superuser=request.user.is_superuser)
if form.is_valid():
search_category = form.cleaned_data['search_category']
query = form.cleaned_data.get('q')
search_method = form.cleaned_data['search_method']
cat = form.cleaned_data.get('cat')
sub_cat = form.cleaned_data.get('sub_cat')
if cat:
directories = directories.filter(cat=cat)
if sub_cat:
directories = directories.filter(sub_cat=sub_cat)
if query and 'tag:' in query:
tag = query.strip('tag:')
directories = directories.filter(tags__icontains=tag)
elif query and search_category:
search_type = '__iexact'
if search_method == 'starts_with':
search_type = '__istartswith'
elif search_method == 'contains':
search_type = '__icontains'
search_filter = {'%s%s' % (search_category, search_type): query}
directories = directories.filter(**search_filter)
directories = directories.order_by('headline')
EventLog.objects.log()
return render_to_response(template_name, {
'directories': directories,
'form': form,
'a_to_z': string.lowercase[:26]
},
context_instance=RequestContext(request))
def search(request, template_name="files/search.html"):
"""
This page lists out all files from newest to oldest.
If a search index is available, this page will also
have the option to search through files.
"""
query = u''
category = None
sub_category = None
group = None
form = FileSearchForm(request.GET, **{'user': request.user})
if form.is_valid():
query = form.cleaned_data.get('q', '')
category = form.cleaned_data.get('file_cat', None)
sub_category = form.cleaned_data.get('file_sub_cat', None)
group = form.cleaned_data.get('group', None)
filters = get_query_filters(request.user, 'files.view_file')
files = File.objects.filter(filters).distinct()
if query:
files = files.filter(
Q(file__icontains=query) | Q(name__icontains=query)
| Q(description__icontains=query) | Q(tags__icontains=query))
if category:
files = files.filter(file_cat=category)
if sub_category:
files = files.filter(file_sub_cat=sub_category)
if group:
files = files.filter(group_id=group)
files = files.order_by('-update_dt')
EventLog.objects.log()
layout = get_setting("module", "files", "layout")
base_template_path = "files/base.html"
if layout == 'grid':
base_template_path = "base-wide.html"
return render_to_response(template_name, {
'files': files,
'form': form,
'layout': layout,
'base_template_path': base_template_path,
},
context_instance=RequestContext(request))
def search(request, template_name="forms/search.html"):
if not has_perm(request.user,'forms.view_form'):
raise Http403
filters = get_query_filters(request.user, 'forms.view_form')
forms = Form.objects.filter(filters).distinct()
query = request.GET.get('q', None)
if query:
forms = forms.filter(Q(title__icontains=query) | Q(intro__icontains=query) | Q(response__icontains=query))
forms = forms.order_by('-pk')
EventLog.objects.log()
return render_to_resp(request=request, template_name=template_name,
context={'forms':forms})
def __init__(self, *args, **kwargs):
super(PhotoSetEditForm, self).__init__(*args, **kwargs)
default_groups = Group.objects.filter(status=True, status_detail="active")
if not self.user.profile.is_superuser:
if 'status_detail' in self.fields:
self.fields.pop('status_detail')
if get_setting('module', 'user_groups', 'permrequiredingd') == 'change':
filters = get_groups_query_filters(self.user,)
else:
filters = get_query_filters(self.user, 'user_groups.view_group', **{'perms_field': False})
default_groups = default_groups.filter(filters).distinct()
self.fields['group'].queryset = default_groups
self.fields['group'].empty_label = None
def search(request, template_name="help_files/search.html"):
""" Help Files Search """
query = request.GET.get('q', None)
if get_setting('site', 'global', 'searchindex') and query:
help_files = HelpFile.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'help_files.view_helpfile')
help_files = HelpFile.objects.filter(filters).distinct()
if not request.user.is_anonymous():
help_files = help_files.select_related()
EventLog.objects.log()
return render_to_response(template_name, {'help_files': help_files},
context_instance=RequestContext(request))
def get_box_list(user):
"""
Generate a list of 2-tuples of form id and form title
This will be used as a special select
"""
from tendenci.apps.boxes.models import Box
from tendenci.apps.perms.utils import get_query_filters
filters = get_query_filters(user, 'boxes.view_box')
boxes = Box.objects.filter(filters)
#To avoid hitting the database n time by calling .object
#We will use the values in the index field.
l = [('', 'None')]
for box in boxes:
l.append((box.pk, box.title))
return l
def search(request, template_name="forms/search.html"):
if not has_perm(request.user,'forms.view_form'):
raise Http403
filters = get_query_filters(request.user, 'forms.view_form')
forms = Form.objects.filter(filters).distinct()
query = request.GET.get('q', None)
if query:
forms = forms.filter(Q(title__icontains=query) | Q(intro__icontains=query) | Q(response__icontains=query))
forms = forms.order_by('-pk')
EventLog.objects.log()
return render_to_resp(request=request, template_name=template_name,
context={'forms':forms})
def get_form_list(user):
"""
Generate a list of 2-tuples of form id and form title
This will be used as a special select
"""
from tendenci.apps.forms_builder.forms.models import Form
from tendenci.apps.perms.utils import get_query_filters
filters = get_query_filters(user, 'forms.view_form')
forms = Form.objects.filter(filters)
#To avoid hitting the database n time by calling .object
#We will use the values in the index field.
l = []
for form in forms:
l.append((form.pk, form.title))
return l
def search(request, template_name="jobs/search.html"):
query = request.GET.get('q', None)
my_pending_jobs = request.GET.get('my_pending_jobs', False)
category = None
subcategory = None
use_search_index = get_setting('site', 'global', 'searchindex') and query
if use_search_index:
jobs = Job.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'jobs.view_job')
jobs = Job.objects.filter(filters).distinct()
if not request.user.is_anonymous():
jobs = jobs.select_related()
form = JobSearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data.get('q')
category = form.cleaned_data.get('categories')
subcategory = form.cleaned_data.get('subcategories')
if category:
jobs = jobs.filter(categories__category=category)
if subcategory:
jobs = jobs.filter(categories__parent=subcategory)
# filter for "my pending jobs"
if my_pending_jobs and not request.user.is_anonymous():
template_name = "jobs/my_pending_jobs.html"
jobs = jobs.filter(
creator_username=request.user.username,
status_detail__contains='pending'
)
if use_search_index:
# reversing is an all-or-nothing action in Whoosh, unfortunately
jobs = jobs.order_by('-status_detail', '-list_type', '-post_dt')
else:
jobs = jobs.order_by('status_detail', 'list_type', '-post_dt')
EventLog.objects.log()
return render_to_response(
template_name,
{'jobs': jobs, 'form': form},
context_instance=RequestContext(request)
)
def nav(context, nav_id, show_title=False, is_site_map=False):
"""
Renders the nav from cache
if not will use the navigation tag for rendering the nav
"""
user = AnonymousUser()
association_id = get_association_id(context)
if is_site_map == 'False':
is_site_map = False
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
if hasattr(user, 'profile'):
association_id = user.profile.current_association_id
try:
nav_id = Variable(nav_id)
nav_id = nav_id.resolve(context)
except:
pass
try:
filters = get_query_filters(user, 'navs.view_nav', association_id=association_id)
navs = Nav.objects.filter(filters) #.filter(id=nav_id)
if user.is_authenticated():
if not user.profile.is_superuser:
navs = navs.distinct()
nav_object = None
nav = None
if navs and len(navs) > 0:
nav_object = navs[0]
if nav_object:
nav = get_nav(nav_object.pk, is_site_map=is_site_map, association_id=association_id)
if not nav:
nav = cache_nav(nav_object, show_title, is_site_map=is_site_map, association_id=association_id)
except:
return None
context.update({
"cached": nav,
"nav_id": nav_id,
"show_title": show_title,
})
return context
def search(request, release_year=None, template_name="news/search.html"):
query = request.GET.get('q', None)
form = NewsSearchForm(request.GET, user=request.user)
if form.is_valid():
try:
news_group = int(form.cleaned_data.get('news_group', None))
except:
news_group = None
if get_setting('site', 'global', 'searchindex') and query:
news = News.objects.search(query, user=request.user)
# use order (existing for all modules) for sorting cause the current
# haystack + whoosh cannot sort by release_dt correctly
news = news.order_by('-order')
else:
filters = get_query_filters(
request.user,
'news.view_news',
association_id=get_association_id_req(request))
news = News.objects.filter(filters).distinct()
news = news.order_by('-release_dt')
if news_group:
news = news.filter(groups__in=[news_group])
if not has_perm(request.user, 'news.view_news'):
news = news.filter(release_dt_local__lte=datetime.now())
EventLog.objects.log()
release_years = News.objects.datetimes('release_dt', 'year', order='DESC')
release_years_list = [rel.year for rel in release_years]
if release_year:
release_year = int(release_year)
if release_year < 1900:
raise Http404
news = news.filter(release_dt_local__year=release_year)
return render_to_response(template_name, {
'search_news': news,
'form': form,
'release_year': release_year,
'release_years_list': release_years_list,
'association_name': get_association_name(request)
},
context_instance=RequestContext(request))
def search(request, cat_slug=None, template_name="videos/list.html"):
"""
This page lists out all videos. The order can be customized.
If a search index is available, this page will also
have the option to search through videos.
"""
form = VideoSearchForm(request.GET)
categories = Category.objects.all()
video_types = VideoType.objects.all()
filters = get_query_filters(request.user, 'videos.view_video')
videos = Video.objects.filter(filters).distinct()
if request.user.is_authenticated:
videos = videos.select_related()
if form.is_valid():
query = form.cleaned_data['q']
cat = form.cleaned_data['cat']
vtype = form.cleaned_data['vtype']
if query:
videos = videos.filter(
Q(title__icontains=query) | Q(description__icontains=query))
if cat:
categories = Category.objects.filter(slug=cat)
category = None
if categories:
category = categories[0]
if category:
videos = videos.filter(category=category)
if vtype:
vtypes = VideoType.objects.filter(slug=vtype)
video_type = None
if vtypes:
video_type = vtypes[0]
if video_type:
videos = videos.filter(video_type=video_type)
if get_setting('module', 'videos', 'order_by_release_dt'):
videos = videos.order_by('-release_dt')
else:
videos = videos.order_by('-position', '-create_dt')
EventLog.objects.log()
return render_to_resp(request=request,
template_name=template_name,
context=locals())
def __init__(self, *args, **kwargs):
super(PhotoEditForm, self).__init__(*args, **kwargs)
default_groups = Group.objects.filter(status=True, status_detail="active")
if self.user and not self.user.profile.is_superuser:
filters = get_query_filters(self.user, 'user_groups.view_group', **{'perms_field': False})
groups = default_groups.filter(filters).distinct()
groups_list = list(groups.values_list('pk', 'name'))
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
else:
groups_list = default_groups.values_list('pk', 'name')
self.fields['group'].choices = groups_list
def search(request, template_name="jobs/search.html"):
query = request.GET.get('q', None)
my_pending_jobs = request.GET.get('my_pending_jobs', False)
filters = get_query_filters(request.user, 'jobs.view_job')
jobs = Job.objects.filter(filters).distinct()
if not request.user.is_anonymous:
jobs = jobs.select_related()
form = JobSearchForm(request.GET)
if form.is_valid():
query = form.cleaned_data.get('q')
cat = form.cleaned_data.get('cat')
sub_cat = form.cleaned_data.get('sub_cat')
if cat:
jobs = jobs.filter(cat=cat)
if sub_cat:
jobs = jobs.filter(sub_cat=sub_cat)
if query:
if 'tag:' in query:
tag = query.strip('tag:')
jobs = jobs.filter(tags__icontains=tag)
else:
jobs = jobs.filter(
Q(title__icontains=query)
| Q(description__icontains=query))
else:
jobs = Job.objects.none()
# filter for "my pending jobs"
if my_pending_jobs and not request.user.is_anonymous:
template_name = "jobs/my_pending_jobs.html"
jobs = jobs.filter(creator_username=request.user.username,
status_detail__contains='pending')
jobs = jobs.order_by('list_type', '-post_dt', '-update_dt')
EventLog.objects.log()
return render_to_resp(request=request,
template_name=template_name,
context={
'jobs': jobs,
'form': form
})
def __init__(self, *args, **kwargs):
mts = kwargs.pop('mts')
self.user = kwargs.pop('user')
super(ProfileSearchForm, self).__init__(*args, **kwargs)
self.fields['first_name'].widget.attrs.update(
{'placeholder': _('Enter first name')})
self.fields['last_name'].widget.attrs.update(
{'placeholder': _('Enter last name')})
self.fields['email'].widget.attrs.update(
{'placeholder': _('Enter email')})
if not mts:
del self.fields['membership_type']
del self.fields['member_only']
else:
choices = [(0, _('SELECT ONE'))]
choices += [(mt.id, mt.name) for mt in mts]
self.fields['membership_type'].widget = forms.widgets.Select(
choices=choices)
self.fields['membership_type'].widget.attrs.update(
{'class': 'form-control'})
# group choices
filters = get_query_filters(self.user, 'user_groups.view_group',
**{'perms_field': False})
group_choices = [
(0, _('SELECT ONE')), (-1, _('NONE - Not in any group!'))
] + list(
Group.objects.filter(status=True, status_detail="active").filter(
filters).distinct().order_by('name').values_list('pk', 'name'))
self.fields['group'].widget = forms.widgets.Select(
choices=group_choices)
self.fields['group'].widget.attrs.update({'class': 'form-control'})
# industry
if get_setting('module', 'users', 'showindustry'):
industry_choices = [(0, _('SELECT ONE'))] + list(
Industry.objects.filter(
status=True, status_detail="active").order_by(
'position', '-update_dt').values_list(
'pk', 'industry_name'))
self.fields['industry'].widget = forms.widgets.Select(
choices=industry_choices)
self.fields['industry'].widget.attrs.update(
{'class': 'form-control'})
else:
del self.fields['industry']
def get_images(self, user=None, status=True, status_detail='active'):
"""
Returns the images of this photosets and filters according
to the given user's permissions.
This makes use of the search index to avoid hitting the database.
"""
# user information
user = user or AnonymousUser()
filters = get_query_filters(user, 'photos.view_image')
photos = Image.objects.filter(filters).filter(photoset=self.pk)
if user.is_authenticated:
photos = photos.distinct()
return photos
def search(request, cat_slug=None, template_name="videos/list.html"):
"""
This page lists out all videos. The order can be customized.
If a search index is available, this page will also
have the option to search through videos.
"""
query = request.GET.get('q', None)
categories = Category.objects.all()
video_types = VideoType.objects.all()
cat = request.GET.get('cat', cat_slug)
vtype = request.GET.get('type', '')
filters = get_query_filters(request.user, 'videos.view_video')
videos = Video.objects.filter(filters).distinct()
if request.user.is_authenticated():
videos = videos.select_related()
if query:
videos = videos.filter(
Q(title__icontains=query) | Q(description__icontains=query))
if cat:
categories = Category.objects.filter(slug=cat)
category = None
if categories:
category = categories[0]
if category:
videos = videos.filter(category=category)
if vtype:
vtypes = VideoType.objects.filter(slug=vtype)
video_type = None
if vtypes:
video_type = vtypes[0]
if video_type:
videos = videos.filter(video_type=video_type)
if get_setting('module', 'videos', 'order_by_release_dt'):
videos = videos.order_by('-release_dt')
else:
videos = videos.order_by('-position', '-create_dt')
EventLog.objects.log()
return render_to_response(template_name,
locals(),
context_instance=RequestContext(request))
def __init__(self, *args, **kwargs):
super(NewsForm, self).__init__(*args, **kwargs)
if self.instance.pk:
self.fields['body'].widget.mce_attrs[
'app_instance_id'] = self.instance.pk
else:
self.fields['body'].widget.mce_attrs['app_instance_id'] = 0
self.fields['groups'].initial = [
Group.objects.get_initial_group_id()
]
default_groups = Group.objects.filter(status=True,
status_detail="active")
#if not self.user.profile.is_superuser:
if not self.user.is_superuser:
if 'status_detail' in self.fields:
self.fields.pop('status_detail')
filters = get_query_filters(self.user, 'user_groups.view_group',
**{'perms_field': False})
groups = default_groups.filter(filters).distinct()
groups_list = list(groups.values_list('pk', 'name'))
users_groups = self.user.profile.get_groups()
for g in users_groups:
if [g.id, g.name] not in groups_list:
groups_list.append([g.id, g.name])
else:
groups_list = default_groups.values_list('pk', 'name')
self.fields['groups'].choices = groups_list
self.fields['google_profile'].help_text = mark_safe(
GOOGLE_PLUS_HELP_TEXT)
self.fields['timezone'].initial = settings.TIME_ZONE
# only show the remove photo checkbox if there is already a thumbnail
if self.instance.thumbnail:
self.fields[
'photo_upload'].help_text = '<input name="remove_photo" id="id_remove_photo" type="checkbox"/> Remove current image: <a target="_blank" href="/files/%s/">%s</a>' % (
self.instance.thumbnail.pk,
basename(self.instance.thumbnail.file.name))
else:
self.fields.pop('remove_photo')
self.fields['release_dt'].initial = datetime.now()
def my_jobs(request, template_name="jobs/my_jobs.html"):
query = request.GET.get('q', None)
if not request.user.is_anonymous():
if get_setting('site', 'global', 'searchindex') and query:
jobs = Job.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'jobs.view_job')
jobs = Job.objects.filter(filters).distinct()
jobs = jobs.select_related()
jobs = jobs.order_by('status_detail', 'list_type', '-post_dt')
jobs = jobs.filter(creator_username=request.user.username)
EventLog.objects.log()
return render_to_response(template_name, {'jobs': jobs},
context_instance=RequestContext(request))
else:
return HttpResponseRedirect(reverse('jobs'))
def search(request, template_name="case_studies/search.html"):
query = request.GET.get('q', None)
if get_setting('site', 'global', 'searchindex') and query:
case_studies = CaseStudy.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'case_studies.view_casestudy')
case_studies = CaseStudy.objects.filter(filters).distinct()
if not request.user.is_anonymous():
case_studies = case_studies.select_related()
case_studies = case_studies.order_by('-create_dt')
services = Service.objects.all()
technologies = Technology.objects.all()
EventLog.objects.log()
return render_to_response(template_name, {'case_studies': case_studies, 'services': services, 'technologies': technologies},
context_instance=RequestContext(request))
def topic(request, id, template_name="help_files/topic.html"):
""" List of topic help files """
topic = get_object_or_404(Topic, pk=id)
filters = get_query_filters(request.user, 'help_files.view_helpfile')
help_files = HelpFile.objects.filter(filters).filter(
topics__in=[topic.pk]).distinct()
if not request.user.is_anonymous:
help_files = help_files.select_related()
EventLog.objects.log(instance=topic)
return render_to_resp(request=request,
template_name=template_name,
context={
'topic': topic,
'help_files': help_files
})
def search(request, template_name="photos/search.html"):
""" Photos search """
query = request.GET.get('q', None)
filters = get_query_filters(request.user, 'photos.view_image')
photos = Image.objects.filter(filters).distinct()
if not request.user.is_anonymous():
photos = photos.select_related()
if query:
photos = photos.filter(
Q(title__icontains=query) | Q(caption__icontains=query)
| Q(tags__icontains=query) | Q(license__name__icontains=query))
photos = photos.order_by('-create_dt')
EventLog.objects.log()
return render_to_response(template_name, {"photos": photos},
context_instance=RequestContext(request))
def search(request, template_name="contacts/search.html"):
if request.user.is_anonymous():
raise Http403
if not has_perm(request.user, 'contacts.view_contact'):
raise Http403
query = request.GET.get('q', None)
if get_setting('site', 'global', 'searchindex') and query:
contacts = Contact.objects.search(query, user=request.user)
else:
filters = get_query_filters(request.user, 'contacts.view_contact')
contacts = Contact.objects.filter(filters).distinct()
if not request.user.is_anonymous():
contacts = contacts.select_related()
contacts = contacts.order_by('-create_dt')
return render_to_response(template_name, {'contacts': contacts},
context_instance=RequestContext(request))
def render(self, context):
context['setting_name'] = unicode(self.template).replace(
'MODULE_THEME_', '').lower()
try:
setting_value = Variable(self.template).resolve(context)
except VariableDoesNotExist:
setting_value = None
if setting_value:
# First try to render this as a box
user = AnonymousUser()
if 'user' in context:
if isinstance(context['user'], User):
user = context['user']
try:
# for performance reason, pass AnonymousUser() to reduce the joins of objectpermissions
# in the meantime, we do want to show public items on homepage
filters = get_query_filters(AnonymousUser(), 'boxes.view_box')
box = Box.objects.filter(filters).filter(pk=setting_value)
context['box'] = box[0]
template = get_template('theme_includes/box.html')
return template.render(context)
except:
# Otherwise try to render a template
try:
template_name = os.path.join('theme_includes',
setting_value)
theme = context.get(
'THEME', get_setting('module', 'theme_editor',
'theme'))
theme_template = get_theme_template(template_name,
theme=theme)
try:
t = get_template(theme_template)
except TemplateDoesNotExist:
t = get_default_template(template_name)
return t.render(context)
except:
if settings.TEMPLATE_DEBUG:
raise
return ''
else:
return ''
def photoset_view_latest(request, template_name="photos/photo-set/latest.html"):
""" View latest photo set """
query = request.GET.get('q', None)
filters = get_query_filters(request.user, 'photos.view_photoset')
photo_sets = PhotoSet.objects.filter(filters).distinct()
if not request.user.is_anonymous():
photo_sets = photo_sets.select_related()
if query:
photo_sets = photo_sets.filter(Q(name__icontains=query)|
Q(description__icontains=query)|
Q(tags__icontains=query))
photo_sets = photo_sets.order_by('position', '-create_dt')
EventLog.objects.log()
return render_to_response(template_name, {"photo_sets": photo_sets},
context_instance=RequestContext(request))
def search(request, slug=None, template_name="staff/search.html"):
"""Staff plugin search list view"""
if slug:
department = get_object_or_404(Department, slug=slug)
else:
department = None
query = request.GET.get('q')
# department_id is legacy code that is still used by some sites
department_id = request.GET.get('department', '')
try:
department_id = int(department_id)
except:
department_id = None
filters = get_query_filters(request.user, 'staff.view_staff')
staff = Staff.objects.filter(filters).distinct()
if not request.user.is_anonymous:
staff = staff.select_related()
if query:
staff = staff.filter(
Q(name__icontains=query) | Q(department__name__icontains=query))
if department:
staff = staff.filter(department__id=department.id)
else:
if department_id:
staff = staff.filter(department__id=department_id)
[department
] = Department.objects.filter(id=department_id)[:1] or [None]
staff = staff.order_by('-position', 'name', '-status', 'status_detail')
EventLog.objects.log()
return render_to_resp(request=request,
template_name=template_name,
context={
'staff_members': staff,
'department': department
})
