예제 #1
0
def recent_widget(parent=False, parent_type=False, request=False):
    return_data = {'recent': [], 'featured': []}
    if parent_type == 'category' and parent:
        return_data['recent'] = image.objects.filter(
            cat__in=parent.get_descendants(include_self=True),
            published=True).filter(access_query(request)).exclude(
                rebuild_assets=True, is_new=True,
                featured=True).order_by('-timestamp_post').select_related(
                    'cat').prefetch_related('assets')[:12]
        return_data['featured'] = image.objects.filter(
            cat__in=parent.get_descendants(include_self=True),
            published=True,
            featured=True).filter(access_query(request)).exclude(
                rebuild_assets=True,
                is_new=True).order_by('-timestamp_post').select_related(
                    'cat').prefetch_related('assets')[:6]
        return return_data
    elif parent_type == 'tag' and parent:
        return_data['recent'] = image.objects.filter(
            tags=parent, published=True).filter(access_query(request)).exclude(
                rebuild_assets=True, is_new=True,
                featured=True).order_by('-timestamp_post').select_related(
                    'cat').prefetch_related('assets')[:12]
        return_data['featured'] = image.objects.filter(
            tags=parent, published=True,
            featured=True).filter(access_query(request)).exclude(
                rebuild_assets=True,
                is_new=True).order_by('-timestamp_post').select_related(
                    'cat').prefetch_related('assets')[:6]
        return return_data
    else:
        return False
예제 #2
0
파일: views.py 프로젝트: lupinia/awi
def finder(request):
    import os
    return_data = (False, '')

    # Fix the trailing slash
    if request.path.endswith('/'):
        basename = os.path.basename(request.path[:-1])
    else:
        basename = os.path.basename(request.path)

    # Check for special features that were improperly categorized
    feature_check = special_feature.objects.filter(
        url__iexact=basename).filter(
            access_query(request)).select_related().first()
    if feature_check and feature_check.url_reverse:
        return_data = (True, reverse(feature_check.url_reverse))

    if not return_data[0]:
        if '.' in basename:
            # Categories don't have dots in the slug
            return return_data
        else:
            cat_check = category.objects.filter(slug__iexact=basename).filter(
                access_query(request)).select_related().first()
            if cat_check:
                return_data = (True,
                               reverse('category',
                                       kwargs={
                                           'cached_url': cat_check.cached_url,
                                       }))

    return return_data
예제 #3
0
파일: views.py 프로젝트: lupinia/awi
	def get_context_data(self, **kwargs):
		context=super(book,self).get_context_data(**kwargs)
		context['pages'] = []
		context['timestamp'] = False
		context['source_url'] = False
		
		# Prepping for the source_url
		if 'www' not in self.request.site.domain:
			site_domain = 'www.%s' % self.request.site.domain
		else:
			site_domain = self.request.site.domain
		
		for page in context['toc'].pages.filter(access_query()).order_by('book_order'):
			canview = page.can_view(self.request)
			if not canview[0]:
				continue
			else:
				context['pages'].append(page)
				
				# source_url should be the url for the first visible page
				if not context['source_url']:
					context['source_url'] = 'http://%s%s' % (site_domain, reverse('page_htm', kwargs={'cached_url':page.cat.cached_url,'slug':page.slug,}))
				
				# timestamp should be the displayed timestamp of whichever page is newest
				cur_page_timestamp = page.display_times()
				if context['timestamp']:
					if context['timestamp'] < cur_page_timestamp[0]['timestamp']:
						context['timestamp'] = cur_page_timestamp[0]['timestamp']
				else:
					context['timestamp'] = cur_page_timestamp[0]['timestamp']
		
		if not context['pages']:
			raise Http404
		
		return context
예제 #4
0
def social_icons(request):
    social_links = contact_link.objects.filter(featured=True).filter(
        access_query(request)).order_by('label')
    if social_links:
        return {'header_icons': social_links}
    else:
        return {'header_icons': False}
예제 #5
0
파일: views.py 프로젝트: lupinia/awi
def finder(request):
	import os
	return_data = (False,'')
	
	basename=os.path.basename(request.path)
	if '.' in basename:
		search_slug_list = basename.split('.')
		search_slug = search_slug_list[0]
		search_type = search_slug_list[-1].lower()
		
		page_check = page.objects.filter(slug__iexact=search_slug).filter(access_query(request)).select_related().prefetch_related('docfiles').first()
		if page_check:
			# Yay!  We found a match that you're allowed to view!
			# Now let's figure out what type of URL to send back.
			# php, htm, and html are definitely a page object
			# pdf, dvi, ps, and epub are definitely an export_file object
			# txt, md, and tex could be either one
			is_page = ['php','htm','html','txt','md','tex']
			is_file = ['pdf','dvi','ps','epub','rtf','docx','txt','md','tex']
			
			# Uploaded files take priority
			if search_type in is_file and not return_data[0]:
				check_file = page_check.docfiles.filter(filetype=search_type).first()
				if check_file:
					return_data = (True, check_file.get_url())
			
			# We didn't find it in the uploaded files, so maybe it's a page?
			if search_type in is_page and not return_data[0]:
				if search_type == 'php' or search_type == 'html':
					search_type = 'htm'
				
				return_data = (True,reverse('page_%s' % search_type, kwargs={'cached_url':page_check.cat.cached_url, 'slug':page_check.slug}))
	
	return return_data
예제 #6
0
파일: views.py 프로젝트: lupinia/awi
	def get_context_data(self, **kwargs):
		context = super(sitemap,self).get_context_data(**kwargs)
		
		context['tags'] = tag.objects.all().annotate(num_leaves=Count('leaf'))
		context['cats'] = category.objects.filter(access_query(self.request)).annotate(num_leaves=Count('leaf'))
		
		return context
예제 #7
0
파일: views.py 프로젝트: lupinia/awi
	def get_context_data(self, **kwargs):
		context = super(single_page,self).get_context_data(**kwargs)
		context['has_reading_mode'] = True
		
		if self.alt_view and context.get('embed_mature_form') == True:
			raise PermissionDenied
		
		if context['object']:
			if context['object'].book_title:
				context['toc'] = context['object'].book_title.pages.filter(access_query(self.request)).select_related('cat').order_by('book_order')
			
			context['alt_version_exclude'] = []
			if context['object'].docfiles:
				context['docfiles'] = []
				for item in context['object'].docfiles.all():
					context['alt_version_exclude'].append(item.filetype)
					context['docfiles'].append(item)
			
			context['body_text'] = sunset_embed(context['object'].body_html, self.request)
			
			if self.request.GET.get('mode', False) == 'read':
				context['showcase_mode'] = True
			elif context['object'].showcase_default and self.request.GET.get('mode', False) != 'normal':
				context['showcase_mode'] = True
			else:
				context['showcase_mode'] = False
			
			if context['can_edit']:
				context['edit_url'] = 'admin:deerbooks_page_change'
			
			context['extra_classes'] = 'writing_page'
		
		return context
예제 #8
0
파일: views.py 프로젝트: outrayjus/awi
    def get_leaves(self, parent=False, parent_type=False):
        leaf_filters = {}

        leaf_ordering = ["-featured", "-timestamp_post"]
        leaf_filters["timestamp_post__lte"] = timezone.now()

        if parent_type == "homepage":
            leaf_ordering = ["-timestamp_post"]
            leaf_filters["featured"] = True
        elif parent_type == "main_feed":
            leaf_ordering = ["-timestamp_post"]
        elif parent_type == "category" and parent:
            leaf_filters["cat"] = parent
        elif parent_type == "tag" and parent:
            leaf_filters["tags"] = parent

        from awi_access.models import access_query

        leaves = (
            leaf.objects.filter(**leaf_filters)
            .filter(access_query(self.request))
            .order_by(*leaf_ordering)
            .select_related()
        )

        if leaves:
            return leaves
        else:
            if parent_type == "category" and parent:
                descendants = parent.get_descendants()
                leaves = (
                    leaf.objects.filter(featured=True, cat__in=descendants)
                    .filter(access_query(self.request))
                    .order_by("-timestamp_post")
                    .select_related()
                )
                if leaves:
                    self.highlight_featured = False
                    return leaves
                else:
                    return False
            else:
                return False
예제 #9
0
파일: views.py 프로젝트: lupinia/awi
def contact_widget(parent=False, parent_type=False, request=False):
    if parent_type == 'category' and parent:
        ancestors = parent.get_ancestors(include_self=True)
        contact_links = contact_link.objects.filter(cat__in=ancestors).filter(
            access_query(request)).order_by('-timestamp_mod')
        if contact_links:
            return contact_links
        else:
            return False
    else:
        return False
예제 #10
0
파일: views.py 프로젝트: lupinia/awi
def subcats(parent=False, parent_type=False, request=False):
    if parent_type == 'category' and parent:
        child_cats = parent.children.filter(access_query(request)).order_by(
            '-featured', 'title').select_related('icon')

        if child_cats:
            return child_cats
        else:
            return False
    else:
        return False
예제 #11
0
파일: views.py 프로젝트: lupinia/awi
def recent_widget(parent=False, parent_type=False, request=False):
	return_data = {'recent': [], 'featured': []}
	if parent_type == 'category' and parent:
		return_data['recent'] = page.objects.filter(cat__in=parent.get_descendants(include_self=True), published=True).filter(access_query(request)).exclude(featured=True).order_by('-timestamp_post').select_related('book_title','cat')[:4]
		return_data['featured'] = page.objects.filter(cat__in=parent.get_descendants(include_self=True), published=True, featured=True).filter(access_query(request)).order_by('-timestamp_post').select_related('book_title','cat')[:2]
		return return_data
	elif parent_type == 'tag' and parent:
		return_data['recent'] = page.objects.filter(tags=parent, published=True).filter(access_query(request)).exclude(featured=True).order_by('-timestamp_post').select_related('book_title','cat')[:4]
		return_data['featured'] = page.objects.filter(tags=parent, published=True, featured=True).filter(access_query(request)).order_by('-timestamp_post').select_related('book_title','cat')[:2]
		return return_data
	else:
		return False
예제 #12
0
파일: views.py 프로젝트: lupinia/awi
    def get_context_data(self, **kwargs):
        context = super(all_cats, self).get_context_data(**kwargs)
        context['view'] = 'catlist'
        context['cats'] = category.objects.filter(access_query(
            self.request)).annotate(num_leaves=Count('leaves'))
        context['breadcrumbs'] = self.breadcrumbs()

        if self.request.GET.get('return_to') and self.request.user.has_perm(
                'deertrees.change_leaf'):
            context['return_to'] = self.request.GET.get('return_to')

        return context
예제 #13
0
def geojson_image(request, slug, **kwargs):
    from deertrees.models import category, tag

    return_data = []
    query = image.objects.filter(access_query(request)).exclude(
        rebuild_assets=True, is_new=True
    ).exclude(Q(geo_lat__isnull=True) | Q(geo_long__isnull=True)).order_by(
        '-timestamp_post').select_related('cat').prefetch_related('assets')

    if slug == 'full_list':
        pass
    elif 'filter_cat' in slug:
        filter = slug.replace('filter_cat_', '')
        filter_obj = get_object_or_404(category, slug=filter)
        query = query.filter(cat=filter_obj)
    elif 'filter_tag' in slug:
        filter = slug.replace('filter_tag_', '')
        filter_obj = get_object_or_404(tag, slug=filter)
        query = query.filter(tag=filter_obj)
    elif slug == 'filter_featured':
        query = query.exclude(featured=False)
    else:
        request.session['deerfind_norecover'] = True
        raise Http404

    for item in query:
        if item.featured:
            marker_color = '#5b4aFF'
        elif item.mature:
            marker_color = '#c0283a'
        else:
            marker_color = '#5b4a71'

        #icon = item.assets.filter(type='icon').first()
        return_data.append({
            'type': 'Feature',
            'geometry': {
                'type': 'Point',
                'coordinates': [item.geo_long, item.geo_lat],
            },
            'properties': {
                'marker-color': marker_color,
                'marker-size': 'small',
                'title': unicode(item),
                'description': unicode(item),
            },
        })

    return json_response(request, data=return_data)
예제 #14
0
파일: views.py 프로젝트: lupinia/awi
	def get_context_data(self, **kwargs):
		context=super(single_page,self).get_context_data(**kwargs)
		
		if context['object']:
			if context['object'].book_title:
				context['toc'] = context['object'].book_title.pages.filter(access_query(self.request)).select_related('cat').order_by('book_order')
			
			context['alt_version_exclude'] = []
			if context['object'].docfiles:
				context['docfiles'] = []
				for item in context['object'].docfiles.all():
					context['alt_version_exclude'].append(item.filetype)
					context['docfiles'].append(item)
		
		return context
예제 #15
0
def finder(request):
    import os
    return_data = (False, '')

    basename = os.path.basename(request.path)
    if '.' in basename:
        search_slug_list = basename.split('.')
        search_slug = search_slug_list[0]

        image_check = image.objects.filter(slug__iexact=search_slug).filter(
            access_query(request)).select_related().first()
        if image_check:
            # Yay!  We found a match!  And it's authorized for viewing.
            return_data = (True,
                           reverse('image_single',
                                   kwargs={
                                       'cached_url':
                                       image_check.cat.cached_url,
                                       'slug': image_check.slug,
                                   }))

    return return_data
예제 #16
0
파일: views.py 프로젝트: lupinia/awi
    def get_context_data(self, **kwargs):
        context = super(contact_page, self).get_context_data(**kwargs)

        if not context.get('breadcrumbs', False):
            context['breadcrumbs'] = []

        context['breadcrumbs'].append({
            'url': reverse('contact'),
            'title': 'Contact'
        })

        if self.request.session.get('deerconnect_success_msg', False):
            context['form'] = ''
            context['error'] = 'mailform_success'
            self.request.session['deerconnect_success_msg'] = False
        elif self.request.session.get('deerconnect_mailsent', False):
            last_message = dateparse.parse_datetime(
                self.request.session.get('deerconnect_mailsent', False))
            expiration = datetime.timedelta(days=1)
            if last_message > timezone.now() - expiration:
                context['form'] = ''
                context['error'] = 'mailform_toosoon'

        contactinfo = contact_link.objects.filter(access_query(
            self.request)).order_by('-im', '-timestamp_mod')
        if contactinfo:
            for link in contactinfo:
                if link.im:
                    if not context.get('links_im', False):
                        context['links_im'] = []
                    context['links_im'].append(link)

                else:
                    if not context.get('links', False):
                        context['links'] = []
                    context['links'].append(link)

        return context
예제 #17
0
파일: views.py 프로젝트: lupinia/awi
	def get_context_data(self, **kwargs):
		context=super(book,self).get_context_data(**kwargs)
		context['pages'] = []
		context['timestamp'] = False
		context['source_url'] = False
		
		# Prepping for the source_url
		if 'www' not in self.request.site.domain:
			site_domain = 'www.%s' % self.request.site.domain
		else:
			site_domain = self.request.site.domain
		
		for page in context['toc'].pages.filter(access_query()).order_by('book_order'):
			canview = page.can_view(self.request)
			if not canview[0]:
				continue
			else:
				page.body = sunset_embed(page.body_html, self.request)
				context['pages'].append(page)
				
				# source_url should be the url for the first visible page
				if not context['source_url']:
					context['source_url'] = 'http://%s%s' % (site_domain, reverse('page_htm', kwargs={'cached_url':page.cat.cached_url,'slug':page.slug,}))
				
				# timestamp should be the displayed timestamp of whichever page is newest
				cur_page_timestamp = page.display_times()
				if context['timestamp']:
					if context['timestamp'] < cur_page_timestamp[0]['timestamp']:
						context['timestamp'] = cur_page_timestamp[0]['timestamp']
				else:
					context['timestamp'] = cur_page_timestamp[0]['timestamp']
		
		if not context['pages']:
			self.request.session['deerfind_norecover'] = True
			raise Http404
		
		return context
예제 #18
0
파일: views.py 프로젝트: lupinia/awi
	def get_context_data(self, **kwargs):
		context = super(contact_page, self).get_context_data(**kwargs)
		
		if self.request.session.get('deerconnect_mailsent',False):
			last_message = dateparse.parse_datetime(self.request.session.get('deerconnect_mailsent',False))
			expiration = datetime.timedelta(days=1)
			if last_message > timezone.now() - expiration:
				context['form'] = ''
				context['error'] = 'mailform_toosoon'
		
		contactinfo = contact_link.objects.filter(access_query(self.request)).order_by('-im','-timestamp_mod')
		if contactinfo:
			for link in contactinfo:
				if link.im:
					if not context.get('links_im',False):
						context['links_im'] = []
					context['links_im'].append(link)
				
				else:
					if not context.get('links',False):
						context['links'] = []
					context['links'].append(link)
		
		return context
예제 #19
0
파일: views.py 프로젝트: lupinia/awi
	def assemble_blocks(self, parent=False, parent_type=False):
		#	BLOCK STRUCTURE
		#	In order of assignment
		#	
		#	main_full_1	- Primary content area, full-width.  Omitted if content_priority is desc
		#	sidebar		- List; add two, then go to main_full_2 if needed.
		#	main_full_2	- Secondary content area, full_width.
		#	sidebar		- List; do one, then go to a main_half block, and alternate as-needed.
		#	main_half - List; there can be as many of these as needed.  Alternate as-needed with sidebar.
		
		blocks_map = settings.DEERTREES_BLOCKS
		blocks = {}
		blocks_count = {}
		assigned_to_blocks = []
		returned_data = [False,{}]
		
		#	Build the list of blocks to assign
		if parent_type == 'homepage':
			blocks_to_assign = ['main_half','sidebar','main_half','sidebar']
		else:
			blocks_to_assign = ['sidebar','sidebar','main_full_2']
			if parent and parent.content_priority != 'desc':
				blocks_to_assign.insert(0,'main_full_1')
		
		#	Loop the known-existing content types, to get a list.  We'll deal with priority later.
		for type, settings_dict in blocks_map.iteritems():
			blocks[type] = []
			blocks_count[type] = 0
		
		#	Content time!
		#	First, check for subcategories and contact links
		if parent_type == 'category' and parent:
			child_cats = parent.children.filter(access_query(self.request)).order_by('title')
			if child_cats:
				blocks['category'] = child_cats
			
			ancestors = parent.get_ancestors(include_self=True)
			contact_links = contact_link.objects.filter(cat__in=ancestors).filter(access_query(self.request)).order_by('-timestamp_mod')
			if contact_links:
				blocks['contact_link'] = contact_links
		
		#	Now get items in this category
		leaves = self.get_leaves(parent,parent_type)
		if leaves:
			#	1.  Loop all of our leaves
			#	2.  For each leaf, loop blocks_map to find its type
			#	3.  Once that check is successful, put it in the correct block dictionary
			for leaf_item in leaves:
				for type, blocksettings in blocks_map.iteritems():
					if blocksettings['is_leaf']:
						if blocks_count[type] <= 50:
							leaf_content = getattr(leaf_item,type,None)
							if leaf_content:
								blocks[type].append(leaf_content)
								blocks_count[type] += 1
		
		#	Clean up empty elements
		empty_keys = [k for k,v in blocks.iteritems() if not v]
		for k in empty_keys:
			del blocks[k]
		
		#	Moment of truth!  Did we actually get anything out of this category?
		if blocks:
			returned_data[0] = True
			
			#	Ok, we how have all of our leaves neatly arranged by type and ready to display.
			#	Now it's time to assign blocks for display
			#	Assignment time!
			#	Start with the special case
			if blocks_to_assign[0] == 'main_full_1' and blocks.get(parent.content_priority,False):
				returned_data[1]['main_full_1'] = {'type':parent.content_priority,'title':blocks_map[parent.content_priority]['title'],'data':blocks[parent.content_priority],'template':blocks_map[parent.content_priority]['template']}
				blocks_to_assign.pop(0)
				blocks.pop(parent.content_priority)
			
			#	Make sure we didn't just pop off the last/only one.
			if blocks:
				order_main = {}
				order_sidebar = {}
				blockorder_main = False
				blockorder_sidebar = False
				
				#	Now, let's build a priority list per region
				for type, content in blocks.iteritems():
					if blocks_map[type].get('main',False):
						order_main[str(blocks_map[type]['main'])] = {'type':type,'title':blocks_map[type]['title'],'data':content,'template':blocks_map[type]['template']}
					if blocks_map[type].get('sidebar',False):
						order_sidebar[str(blocks_map[type]['sidebar'])] = {'type':type,'title':blocks_map[type]['title'],'data':content,'template':blocks_map[type]['template']}
				
				#	And now put them in order
				if order_main:
					blockorder_main = []
					for key,value in sorted(order_main.iteritems()):
						blockorder_main.append(value)
					
				if order_sidebar:
					blockorder_sidebar = []
					for key,value in sorted(order_sidebar.iteritems()):
						blockorder_sidebar.append(value)
				
				#	Assign the main blocks first 
				for blockname in blocks_to_assign:
					if 'main' in blockname and blockorder_main:
						for blockdata in blockorder_main:
							if blockdata['type'] not in assigned_to_blocks:
								if not returned_data[1].get('main_half',False):
									returned_data[1]['main_half'] = []
								
								if blockname == 'main_half':
									returned_data[1]['main_half'].append(blockdata)
								else:
									returned_data[1][blockname] = blockdata
								assigned_to_blocks.append(blockdata['type'])
								break
					
					elif 'sidebar' in blockname and blockorder_sidebar:
						for blockdata in blockorder_sidebar:
							if blockdata['type'] not in assigned_to_blocks:
								if not returned_data[1].get('sidebar',False):
									returned_data[1]['sidebar'] = []
								returned_data[1]['sidebar'].append(blockdata)
								assigned_to_blocks.append(blockdata['type'])
								break
				
				#	Quick bit of cleanup
				for content_type in assigned_to_blocks:
					blocks.pop(content_type,None)
				
				#	Is there anything left?
				if blocks:
					#	Seriously?  Ok then, we'll just go through whatever's left.
					#	Sidebar takes priority.
					for sidebar_data in blockorder_sidebar:
						if sidebar_data['type'] not in assigned_to_blocks:
							returned_data[1]['sidebar'].append(sidebar_data)
							assigned_to_blocks.append(sidebar_data['type'])
					
					for main_data in blockorder_main:
						if main_data['type'] not in assigned_to_blocks:
							if not returned_data[1]['main_half']:
								returned_data[1]['main_half'] = []
							returned_data[1]['main_half'].append(main_data)
							assigned_to_blocks.append(main_data['type'])
		
		return returned_data
예제 #20
0
파일: views.py 프로젝트: lupinia/awi
	def get_leaves(self, parent=False, parent_type=False):
		leaf_filters = {}
		blocks_map = settings.DEERTREES_BLOCKS
		leaf_list = []
		prefetch_list = []
		for type, settings_dict in blocks_map.iteritems():
			if settings_dict.get('is_leaf',False):
				leaf_list.append(type)
				leaf_list.append('%s__cat' % type)
				
				if settings_dict.get('prefetch',False):
					for pf_field in settings_dict['prefetch']:
						prefetch_list.append('%s__%s' % (type, pf_field))
				
				if settings_dict.get('related',False):
					for sr_field in settings_dict['related']:
						leaf_list.append('%s__%s' % (type, sr_field))
		
		leaf_ordering = ['-featured','-timestamp_post']
		leaf_filters['timestamp_post__lte'] = timezone.now()
		
		if parent_type == 'homepage':
			leaf_ordering = ['-timestamp_post',]
			leaf_filters['featured'] = True
		elif parent_type == 'main_feed':
			leaf_ordering = ['-timestamp_post',]
		elif parent_type == 'category' and parent:
			leaf_filters['cat'] = parent
		elif parent_type == 'tag' and parent:
			leaf_filters['tags'] = parent
		
		leaves = leaf.objects.select_related(*leaf_list).prefetch_related(*prefetch_list).filter(**leaf_filters).filter(access_query(self.request)).order_by(*leaf_ordering)
		
		if leaves:
			return leaves
		else:
			if parent_type == 'category' and parent:
				descendants = parent.get_descendants()
				leaves = leaf.objects.select_related(*leaf_list).prefetch_related(*prefetch_list).filter(featured=True, cat__in=descendants).filter(access_query(self.request)).order_by('-timestamp_post')
				if leaves:
					self.highlight_featured = False
					return leaves
				else:
					return False
			else:
				return False
예제 #21
0
파일: sitemaps.py 프로젝트: lupinia/awi
	def items(self):
		return special_feature.objects.filter(access_query()).select_related('cat')
예제 #22
0
파일: sitemaps.py 프로젝트: lupinia/awi
	def items(self):
		return category.objects.filter(access_query()).filter(sitemap_include=True)
예제 #23
0
파일: sitemaps.py 프로젝트: lupinia/awi
	def items(self):
		return page.objects.filter(access_query()).select_related('cat')
예제 #24
0
파일: views.py 프로젝트: lupinia/awi
    def get_leaves(self, parent=False, parent_type=False, is_feed=False):
        blocks_main = settings.DEERTREES_BLOCKS
        leaf_filters = {}
        related_list = []
        prefetch_list = []

        for type, settings_dict in blocks_main.iteritems():
            if settings_dict.get('is_leaf', False):
                related_list.append(type)
                related_list.append('%s__cat' % type)
                related_list.append('%s__access_code' % type)

            if settings_dict.get('prefetch', False):
                for pf_field in settings_dict['prefetch']:
                    prefetch_list.append('%s__%s' % (type, pf_field))

            if settings_dict.get('related', False):
                for sr_field in settings_dict['related']:
                    related_list.append('%s__%s' % (type, sr_field))

        leaf_ordering = ['-featured', '-timestamp_post']
        leaf_filters['timestamp_post__lte'] = timezone.now()

        # Special cases
        # Site home
        if parent_type == 'homepage':
            leaf_ordering = [
                '-timestamp_post',
            ]
            leaf_filters['featured'] = True
        # RSS feed (Home)
        elif parent_type == 'main_feed':
            leaf_ordering = [
                '-timestamp_post',
            ]
        #
        elif parent_type == 'category' and parent:
            leaf_filters['cat'] = parent
        elif parent_type == 'tag' and parent:
            leaf_filters['tags'] = parent
        elif parent_type == 'root' and parent:
            descendants = parent.get_descendants()
            self.highlight_featured = False
            leaf_ordering = [
                '-timestamp_post',
            ]
            leaf_filters['featured'] = True
            leaf_filters['cat__in'] = descendants

        if is_feed:
            leaf_ordering = [
                '-timestamp_post',
            ]

        leaves = leaf.objects.select_related(*related_list).prefetch_related(
            *prefetch_list).filter(**leaf_filters).filter(
                access_query(getattr(self, 'request',
                                     False))).order_by(*leaf_ordering)

        if leaves or is_feed:
            return leaves
        else:
            return False
예제 #25
0
파일: sitemaps.py 프로젝트: lupinia/awi
 def items(self):
     return page.objects.filter(access_query()).select_related('cat')
예제 #26
0
파일: sitemaps.py 프로젝트: lupinia/awi
 def items(self):
     return category.objects.filter(
         access_query()).filter(sitemap_include=True)
예제 #27
0
def social_icons(request):
	social_links = contact_link.objects.filter(featured=True).filter(access_query(request)).order_by('label')
	if social_links:
		return {'header_icons':social_links}
	else:
		return {'header_icons':False}
예제 #28
0
파일: sitemaps.py 프로젝트: lupinia/awi
 def items(self):
     return special_feature.objects.filter(
         access_query()).select_related('cat')
예제 #29
0
def sunset_embed(body, request=False):
    # Moved the import down here to avoid a circular import
    from sunset.models import image
    self_closing = [
        'sunset',
    ]

    if body and "<sunset" in body:
        body_raw = BeautifulSoup(body, selfClosingTags=self_closing)
        imglist = body_raw.findAll('sunset')

        for imgtag in imglist:
            err = 'Unknown error parsing Sunset embed tag'
            new_tag = ''
            img_pk = imgtag.get('id', False)
            cur_type = imgtag.get('type', 'icon')
            if img_pk:
                img_check = image.objects.filter(pk=int(img_pk)).filter(
                    access_query(request)).select_related('cat')

                if img_check:
                    cur_img = img_check.first()
                    asset_check = cur_img.assets.filter(type=cur_type)

                    if asset_check:
                        cur_asset = asset_check.first()
                        new_tag = BeautifulSoup(selfClosingTags=self_closing)
                        new_a = Tag(new_tag, 'a')
                        new_img = Tag(new_tag, 'img')

                        new_a['class'] = 'sunset_embed sunset_%s' % cur_type
                        new_a['href'] = cur_img.get_absolute_url()
                        new_a['title'] = cur_img

                        new_img['alt'] = cur_img
                        new_img['title'] = cur_img

                        new_img['src'] = cur_asset.get_url()

                        new_tag.insert(0, new_a)
                        new_a.insert(0, new_img)
                        err = False

                    else:
                        err = 'Sunset image asset type specified in embed tag was not found'

                else:
                    err = 'Sunset image specified in embed tag was not found'

            else:
                err = 'Invalid or missing image ID in Sunset embed tag'

            if err:
                imgtag.replaceWith(
                    Comment('%s.  Original was:  %s' % (err, imgtag)))
            else:
                imgtag.replaceWith(new_tag)

        return unicode(body_raw)

    else:
        # Nothing to do.
        return body