mailto() - Code Metrics - Inspection of "Fixed small bugs" - GEANT/met - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 629cab...fd405c )

by Andrea

created 2016-11-17 15:03 UTC

mailto() A

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	2
dl	0
loc	6
rs	9.4285
c	0
b	0
f	0

#################################################################
# MET v2 Metadate Explorer Tool
#
# This Software is Open Source. See License: https://github.com/TERENA/met/blob/master/LICENSE.md
# Copyright (c) 2012, TERENA All rights reserved.
#
# This Software is based on MET v1 developed for TERENA by Yaco Sistemas, http://www.yaco.es/
# MET v2 was developed for TERENA by Tamim Ziai, DAASI International GmbH, http://www.daasi.de
# Current version of MET has been revised for performance improvements by Andrea Biancini,
# Consortium GARR, http://www.garr.it
#########################################################################################

from django import template
from django.template.base import Node, TemplateSyntaxError
from django.template.defaultfilters import stringfilter
from django.utils.safestring import mark_safe, SafeData
from met.metadataparser.models import Federation
from met.metadataparser.xmlparser import DESCRIPTOR_TYPES, DESCRIPTOR_TYPES_DISPLAY
from met.metadataparser.query_export import export_modes
from met.metadataparser.summary_export import export_summary_modes
from urllib import urlencode

register = template.Library()


class AddGetParameter(Node):
    def __init__(self, values):
        self.values = values
        
    def render(self, context):
        req = template.resolve_variable('request', context)
        params = req.GET.copy()
        for key, value in self.values.items():
            params[key] = value.resolve(context)
        return '?%s' %  params.urlencode()


@register.tag()
def add_get(parser, token):
    pairs = token.split_contents()[1:]
    values = {}
    for pair in pairs:
        s = pair.split('=', 1)
        values[s[0]] = parser.compile_filter(s[1])
    return AddGetParameter(values)


@register.inclusion_tag('metadataparser/bootstrap_form.html')
def bootstrap_form(form, cancel_link='..', delete_link=True):
    return {'form': form,
            'cancel_link': cancel_link,
            'delete_link': delete_link}


@register.inclusion_tag('metadataparser/bootstrap_searchform.html')
def bootstrap_searchform(form):
    return {'form': form}


@register.inclusion_tag('metadataparser/federations_summary_tag.html', takes_context=True)
def federations_summary(context, queryname, counts, federations=None):
    if not federations:
        federations = Federation.objects.all()

    user = context.get('user', None)
    add_federation = user and user.has_perm('metadataparser.add_federation')

    return {'federations': federations,
            'add_federation': add_federation,
            'queryname': queryname,
            'counts': counts,
            'entity_types': DESCRIPTOR_TYPES}


@register.inclusion_tag('metadataparser/tag_entity_list.html', takes_context=True)
def entity_list(context, entities, categories=None, pagination=None, curfed=None, show_total=True, append_query=None, onclick_page=None, onclick_export=None):
    request = context.get('request', None)
    lang = 'en'
    if request:
        lang = request.GET.get('lang', 'en')

    return {'request': request,
            'entities': entities,
            'categories': categories,
            'curfed' : curfed,
            'show_filters': context.get('show_filters'),
            'append_query': append_query,
            'show_total': show_total,
            'lang': lang,
            'pagination': pagination,
            'onclick_page': onclick_page,
            'onclick_export': onclick_export,
            'entity_types': DESCRIPTOR_TYPES}


@register.inclusion_tag('metadataparser/tag_entity_filters.html', takes_context=True)
def entity_filters(context, entities, categories):
    entity_types = ('All', ) + DESCRIPTOR_TYPES
    request = context.get('request')
    entity_type = request.GET.get('entity_type', '')
    entity_category = request.GET.get('entity_category', '')
    rquery = request.GET.copy()
    for filt in 'entity_type', 'entity_category', 'page':
        if filt in rquery:
            rquery.pop(filt)
    if not entity_type:
        entity_type = 'All'
    if not entity_category:
        entity_category = 'All'
    query = urlencode(rquery)
    filter_base_path = request.path
    return {'filter_base_path': filter_base_path,
            'otherparams': query,
            'entity_types': entity_types,
            'entity_type': entity_type,
            'entity_category': entity_category,
            'entities': entities,
            'categories': categories }


@register.simple_tag()
def entity_filter_url(base_path, filt, otherparams=None):
    url = base_path
    if filt != 'All':
        url += '?entity_type=%s' % filt
        if otherparams:
            url += '&%s' % otherparams
    elif otherparams:
        url += '?%s' % otherparams

    return url


@register.simple_tag()
def entitycategory_filter_url(base_path, filt, otherparams=None):
    url = base_path
    if filt != 'All':
        url += '?entity_category=%s' % filt
        if otherparams:
            url += '&%s' % otherparams
    elif otherparams:
        url += '?%s' % otherparams

    return url


@register.inclusion_tag('metadataparser/export-menu.html', takes_context=True)
def export_menu(context, entities, append_query=None, onclick=None):
    request = context.get('request')
    copy_query = request.GET.copy()
    if 'page' in copy_query:
        copy_query.pop('page')
    query = copy_query.urlencode()
    base_path = request.path
    formats = []
    for mode in export_modes.keys():
        url = base_path
        if query:
            url += '?%s&format=%s' % (query, mode)
        else:
            url += '?format=%s' % (mode)
        if append_query:
            url += "&%s" % (append_query)
        formats.append({'url': url, 'label': mode, 'onclick': onclick})

    return {'formats': formats}


@register.inclusion_tag('metadataparser/export-menu.html')
def export_summary_menu(query, onclick=None):
    formats = []
    for mode in export_summary_modes.keys():
        urlquery = {'format': mode,
                    'export': query}
        url = "./?%(query)s" % {'query': urlencode(urlquery)}
        formats.append({'url': url, 'label': mode, 'onclick': onclick})

    return {'formats': formats}


@register.simple_tag()
def entities_count(entity_qs, entity_type=None):
    if entity_type and entity_type != 'All':
        return entity_qs.filter(types__xmlname=entity_type).count()
    else:
        return entity_qs.count()


@register.simple_tag()
def get_fed_total(totals, entity_type='All'):
    tot_count = 0
    for curtotal in totals:
        if entity_type == 'All' or curtotal['types__xmlname'] == entity_type:
            tot_count += curtotal['types__xmlname__count']
    return tot_count


@register.simple_tag()
def get_fed_count(counts, federation='All', entity_type='All'):
    count = counts[entity_type]

    fed_count = 0
    for curcount in count:
        if federation == 'All' or curcount['federations__id'] == federation:
            fed_count += curcount['federations__id__count']
    return fed_count


@register.simple_tag(takes_context=True)
def l10n_property(context, prop, lang):
    if isinstance(prop, dict) and len(prop) > 0:
        if not lang:
            lang = context.get('LANGUAGE_CODE', None)
        if lang and lang in prop:
            return prop.get(lang)
        else:
            return prop[prop.keys()[0]]
    return prop



@register.simple_tag(takes_context=True)
def organization_property(context, organizations, prop, lang):
    if not isinstance(organizations, list):
        return prop

    lang = lang or context.get('LANGUAGE_CODE', None)
    for organization in organizations:
        if prop in organization:
            val = organization[prop]
            if organization['lang'] == lang:
                val = organization[prop]

    return val


@register.simple_tag()
def get_property(obj, prop=None):
    uprop = unicode(prop)
    if not uprop:
        return '<a href="%(link)s">%(name)s</a>' % {"link": obj.get_absolute_url(),
                                                    "name": unicode(obj),
                                                    }
    if isinstance(obj, dict):
        return obj.get(prop, None)
    if getattr(getattr(obj, uprop, None), 'all', None):
        return '. '.join(['<a href="%(link)s">%(name)s</a>' % {"link": item.get_absolute_url(),
                                                    "name": unicode(item)}
                          for item in getattr(obj, uprop).all()])
    if isinstance(getattr(obj, uprop, ''), list):
        return ', '.join(getattr(obj, uprop, []))
    return getattr(obj, uprop, '')


@register.simple_tag(takes_context=True)
def active_url(context, pattern):
    request = context.get('request')
    if request.path == pattern:
        return 'active'
    return ''


@register.filter(name='display_etype')
def display_etype(value, separator=', '):
    if isinstance(value, list):
        return separator.join(value)
    elif hasattr(value, 'all'):
        return separator.join([unicode(item) for item in value.all()])
    else:
        if value in DESCRIPTOR_TYPES_DISPLAY:
            return DESCRIPTOR_TYPES_DISPLAY.get(value)
        else:
            return value


@register.filter(name='mailto')
def mailto(value):
    if value.startswith('mailto:'):
        return value
    else:
        return 'mailto:%s' % value

@register.filter(name='wrap')
def wrap(value, length):
    value = unicode(value)
    if len(value) > length:
        return "%s..." % value[:length]
    return value


class CanEdit(Node):
    child_nodelists = 'nodelist'

    def __init__(self, obj, nodelist):
        self.obj = obj
        self.nodelist = nodelist

    @classmethod
    def __repr__(cls):
        return "<CanEdit>"

    def render(self, context):
        obj = self.obj.resolve(context, True)
        user = context.get('user')
        if obj.can_edit(user, False):
            return self.nodelist.render(context)
        else:
            return ''


def do_canedit(parser, token):
    bits = list(token.split_contents())
    if len(bits) != 2:
        raise TemplateSyntaxError("%r takes 1 argument" % bits[0])
    end_tag = 'end' + bits[0]
    nodelist = parser.parse((end_tag,))
    obj = parser.compile_filter(bits[1])
    token = parser.next_token()
    return CanEdit(obj, nodelist)


@register.tag
def canedit(parser, token):
    """
    Outputs the contents of the block if user has edit pemission

    Examples::

        {% canedit obj %}
            ...
        {% endcanedit %}
    """
    return do_canedit(parser, token)

@register.filter
@stringfilter
def split(value, splitter='|'):
    if not isinstance(value, SafeData):
        value = mark_safe(value)
    return value.split(splitter)


1			#################################################################
2			# MET v2 Metadate Explorer Tool
3			#
4			# This Software is Open Source. See License: https://github.com/TERENA/met/blob/master/LICENSE.md
5			# Copyright (c) 2012, TERENA All rights reserved.
6			#
7			# This Software is based on MET v1 developed for TERENA by Yaco Sistemas, http://www.yaco.es/
8			# MET v2 was developed for TERENA by Tamim Ziai, DAASI International GmbH, http://www.daasi.de
9			# Current version of MET has been revised for performance improvements by Andrea Biancini,
10			# Consortium GARR, http://www.garr.it
11			#########################################################################################
12
13			from django import template
14			from django.template.base import Node, TemplateSyntaxError
15			from django.template.defaultfilters import stringfilter
16			from django.utils.safestring import mark_safe, SafeData
17			from met.metadataparser.models import Federation
18			from met.metadataparser.xmlparser import DESCRIPTOR_TYPES, DESCRIPTOR_TYPES_DISPLAY
19			from met.metadataparser.query_export import export_modes
20			from met.metadataparser.summary_export import export_summary_modes
21			from urllib import urlencode
22
23			register = template.Library()
24
25
26			class AddGetParameter(Node):
27			def __init__(self, values):
28			self.values = values
29
30			def render(self, context):
31			req = template.resolve_variable('request', context)
32			params = req.GET.copy()
33			for key, value in self.values.items():
34			params[key] = value.resolve(context)
35			return '?%s' % params.urlencode()
36
37
38			@register.tag()
39			def add_get(parser, token):
40			pairs = token.split_contents()[1:]
41			values = {}
42			for pair in pairs:
43			s = pair.split('=', 1)
44			values[s[0]] = parser.compile_filter(s[1])
45			return AddGetParameter(values)
46
47
48			@register.inclusion_tag('metadataparser/bootstrap_form.html')
49			def bootstrap_form(form, cancel_link='..', delete_link=True):
50			return {'form': form,
51			'cancel_link': cancel_link,
52			'delete_link': delete_link}
53
54
55			@register.inclusion_tag('metadataparser/bootstrap_searchform.html')
56			def bootstrap_searchform(form):
57			return {'form': form}
58
59
60			@register.inclusion_tag('metadataparser/federations_summary_tag.html', takes_context=True)
61			def federations_summary(context, queryname, counts, federations=None):
62			if not federations:
63			federations = Federation.objects.all()
64
65			user = context.get('user', None)
66			add_federation = user and user.has_perm('metadataparser.add_federation')
67
68			return {'federations': federations,
69			'add_federation': add_federation,
70			'queryname': queryname,
71			'counts': counts,
72			'entity_types': DESCRIPTOR_TYPES}
73
74
75			@register.inclusion_tag('metadataparser/tag_entity_list.html', takes_context=True)
76			def entity_list(context, entities, categories=None, pagination=None, curfed=None, show_total=True, append_query=None, onclick_page=None, onclick_export=None):
77			request = context.get('request', None)
78			lang = 'en'
79			if request:
80			lang = request.GET.get('lang', 'en')
81
82			return {'request': request,
83			'entities': entities,
84			'categories': categories,
85			'curfed' : curfed,
86			'show_filters': context.get('show_filters'),
87			'append_query': append_query,
88			'show_total': show_total,
89			'lang': lang,
90			'pagination': pagination,
91			'onclick_page': onclick_page,
92			'onclick_export': onclick_export,
93			'entity_types': DESCRIPTOR_TYPES}
94
95
96			@register.inclusion_tag('metadataparser/tag_entity_filters.html', takes_context=True)
97			def entity_filters(context, entities, categories):
98			entity_types = ('All', ) + DESCRIPTOR_TYPES
99			request = context.get('request')
100			entity_type = request.GET.get('entity_type', '')
101			entity_category = request.GET.get('entity_category', '')
102			rquery = request.GET.copy()
103			for filt in 'entity_type', 'entity_category', 'page':
104			if filt in rquery:
105			rquery.pop(filt)
106			if not entity_type:
107			entity_type = 'All'
108			if not entity_category:
109			entity_category = 'All'
110			query = urlencode(rquery)
111			filter_base_path = request.path
112			return {'filter_base_path': filter_base_path,
113			'otherparams': query,
114			'entity_types': entity_types,
115			'entity_type': entity_type,
116			'entity_category': entity_category,
117			'entities': entities,
118			'categories': categories }
119
120
121			@register.simple_tag()
122			def entity_filter_url(base_path, filt, otherparams=None):
123			url = base_path
124			if filt != 'All':
125			url += '?entity_type=%s' % filt
126			if otherparams:
127			url += '&%s' % otherparams
128			elif otherparams:
129			url += '?%s' % otherparams
130
131			return url
132
133
134			@register.simple_tag()
135			def entitycategory_filter_url(base_path, filt, otherparams=None):
136			url = base_path
137			if filt != 'All':
138			url += '?entity_category=%s' % filt
139			if otherparams:
140			url += '&%s' % otherparams
141			elif otherparams:
142			url += '?%s' % otherparams
143
144			return url
145
146
147			@register.inclusion_tag('metadataparser/export-menu.html', takes_context=True)
148			def export_menu(context, entities, append_query=None, onclick=None):
149			request = context.get('request')
150			copy_query = request.GET.copy()
151			if 'page' in copy_query:
152			copy_query.pop('page')
153			query = copy_query.urlencode()
154			base_path = request.path
155			formats = []
156			for mode in export_modes.keys():
157			url = base_path
158			if query:
159			url += '?%s&format=%s' % (query, mode)
160			else:
161			url += '?format=%s' % (mode)
162			if append_query:
163			url += "&%s" % (append_query)
164			formats.append({'url': url, 'label': mode, 'onclick': onclick})
165
166			return {'formats': formats}
167
168
169			@register.inclusion_tag('metadataparser/export-menu.html')
170			def export_summary_menu(query, onclick=None):
171			formats = []
172			for mode in export_summary_modes.keys():
173			urlquery = {'format': mode,
174			'export': query}
175			url = "./?%(query)s" % {'query': urlencode(urlquery)}
176			formats.append({'url': url, 'label': mode, 'onclick': onclick})
177
178			return {'formats': formats}
179
180
181			@register.simple_tag()
182			def entities_count(entity_qs, entity_type=None):
183			if entity_type and entity_type != 'All':
184			return entity_qs.filter(types__xmlname=entity_type).count()
185			else:
186			return entity_qs.count()
187
188
189			@register.simple_tag()
190			def get_fed_total(totals, entity_type='All'):
191			tot_count = 0
192			for curtotal in totals:
193			if entity_type == 'All' or curtotal['types__xmlname'] == entity_type:
194			tot_count += curtotal['types__xmlname__count']
195			return tot_count
196
197
198			@register.simple_tag()
199			def get_fed_count(counts, federation='All', entity_type='All'):
200			count = counts[entity_type]
201
202			fed_count = 0
203			for curcount in count:
204			if federation == 'All' or curcount['federations__id'] == federation:
205			fed_count += curcount['federations__id__count']
206			return fed_count
207
208
209			@register.simple_tag(takes_context=True)
210			def l10n_property(context, prop, lang):
211			if isinstance(prop, dict) and len(prop) > 0:
212			if not lang:
213			lang = context.get('LANGUAGE_CODE', None)
214			if lang and lang in prop:
215			return prop.get(lang)
216			else:
217			return prop[prop.keys()[0]]
218			return prop
219
220
221
222			@register.simple_tag(takes_context=True)
223			def organization_property(context, organizations, prop, lang):
224			if not isinstance(organizations, list):
225			return prop
226
227			lang = lang or context.get('LANGUAGE_CODE', None)
228			for organization in organizations:
229			if prop in organization:
230			val = organization[prop]
231			if organization['lang'] == lang:
232			val = organization[prop]
233
234			return val
235
236
237			@register.simple_tag()
238			def get_property(obj, prop=None):
239			uprop = unicode(prop)
240			if not uprop:
241			return '<a href="%(link)s">%(name)s</a>' % {"link": obj.get_absolute_url(),
242			"name": unicode(obj),
243			}
244			if isinstance(obj, dict):
245			return obj.get(prop, None)
246			if getattr(getattr(obj, uprop, None), 'all', None):
247			return '. '.join(['<a href="%(link)s">%(name)s</a>' % {"link": item.get_absolute_url(),
248			"name": unicode(item)}
249			for item in getattr(obj, uprop).all()])
250			if isinstance(getattr(obj, uprop, ''), list):
251			return ', '.join(getattr(obj, uprop, []))
252			return getattr(obj, uprop, '')
253
254
255			@register.simple_tag(takes_context=True)
256			def active_url(context, pattern):
257			request = context.get('request')
258			if request.path == pattern:
259			return 'active'
260			return ''
261
262
263			@register.filter(name='display_etype')
264			def display_etype(value, separator=', '):
265			if isinstance(value, list):
266			return separator.join(value)
267			elif hasattr(value, 'all'):
268			return separator.join([unicode(item) for item in value.all()])
269			else:
270			if value in DESCRIPTOR_TYPES_DISPLAY:
271			return DESCRIPTOR_TYPES_DISPLAY.get(value)
272			else:
273			return value
274
275
276			@register.filter(name='mailto')
277			def mailto(value):
278			if value.startswith('mailto:'):
279			return value
280			else:
281			return 'mailto:%s' % value
282
283			@register.filter(name='wrap')
284			def wrap(value, length):
285			value = unicode(value)
286			if len(value) > length:
287			return "%s..." % value[:length]
288			return value
289
290
291			class CanEdit(Node):
292			child_nodelists = 'nodelist'
293
294			def __init__(self, obj, nodelist):
295			self.obj = obj
296			self.nodelist = nodelist
297
298			@classmethod
299			def __repr__(cls):
300			return "<CanEdit>"
301
302			def render(self, context):
303			obj = self.obj.resolve(context, True)
304			user = context.get('user')
305			if obj.can_edit(user, False):
306			return self.nodelist.render(context)
307			else:
308			return ''
309
310
311			def do_canedit(parser, token):
312			bits = list(token.split_contents())
313			if len(bits) != 2:
314			raise TemplateSyntaxError("%r takes 1 argument" % bits[0])
315			end_tag = 'end' + bits[0]
316			nodelist = parser.parse((end_tag,))
317			obj = parser.compile_filter(bits[1])
318			token = parser.next_token()
319			return CanEdit(obj, nodelist)
320
321
322			@register.tag
323			def canedit(parser, token):
324			"""
325			Outputs the contents of the block if user has edit pemission
326
327			Examples::
328
329			{% canedit obj %}
330			...
331			{% endcanedit %}
332			"""
333			return do_canedit(parser, token)
334
335			@register.filter
336			@stringfilter
337			def split(value, splitter='\|'):
338			if not isinstance(value, SafeData):
339			value = mark_safe(value)
340			return value.split(splitter)
341

GEANT / met

Push — master ( 629cab...fd405c )

mailto() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like