CanEdit.__init__() - Code Metrics - Inspection of "Merged modifications" - GEANT/met - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 28b0ba...17cdbf )

by Andrea

created 2016-07-26 13:10 UTC

CanEdit.init() A

↳ Parent: CanEdit

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	3
rs	10
cc	1

#################################################################
# 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, pagination=None, curfed=None, show_total=True, append_query=None):
    request = context.get('request', None)
    lang = 'en'
    if request:
        lang = request.GET.get('lang', 'en')

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


@register.inclusion_tag('metadataparser/tag_entity_filters.html', takes_context=True)
def entity_filters(context, entities):
    entity_types = ('All', ) + DESCRIPTOR_TYPES
    request = context.get('request')
    entity_type = request.GET.get('entity_type', '')
    rquery = request.GET.copy()
    for filter in 'entity_type', 'page':
        if filter in rquery:
            rquery.pop(filter)
    if not entity_type:
        entity_type = '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,
            'entities': entities}


@register.simple_tag()
def entity_filter_url(base_path, filter, otherparams=None):
    url = base_path
    if filter != 'All':
        url += '?entity_type=%s' % filter
        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):
    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})

    return {'formats': formats}


@register.inclusion_tag('metadataparser/export-menu.html')
def export_summary_menu(query):
    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})

    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='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, pagination=None, curfed=None, show_total=True, append_query=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			'curfed' : curfed,
85			'show_filters': context.get('show_filters'),
86			'append_query': append_query,
87			'show_total': show_total,
88			'lang': lang,
89			'pagination': pagination,
90			'entity_types': DESCRIPTOR_TYPES}
91
92
93			@register.inclusion_tag('metadataparser/tag_entity_filters.html', takes_context=True)
94			def entity_filters(context, entities):
95			entity_types = ('All', ) + DESCRIPTOR_TYPES
96			request = context.get('request')
97			entity_type = request.GET.get('entity_type', '')
98			rquery = request.GET.copy()
99			for filter in 'entity_type', 'page':
100			if filter in rquery:
101			rquery.pop(filter)
102			if not entity_type:
103			entity_type = 'All'
104			query = urlencode(rquery)
105			filter_base_path = request.path
106			return {'filter_base_path': filter_base_path,
107			'otherparams': query,
108			'entity_types': entity_types,
109			'entity_type': entity_type,
110			'entities': entities}
111
112
113			@register.simple_tag()
114			def entity_filter_url(base_path, filter, otherparams=None):
115			url = base_path
116			if filter != 'All':
117			url += '?entity_type=%s' % filter
118			if otherparams:
119			url += '&%s' % otherparams
120			elif otherparams:
121			url += '?%s' % otherparams
122
123			return url
124
125
126			@register.inclusion_tag('metadataparser/export-menu.html', takes_context=True)
127			def export_menu(context, entities, append_query=None):
128			request = context.get('request')
129			copy_query = request.GET.copy()
130			if 'page' in copy_query:
131			copy_query.pop('page')
132			query = copy_query.urlencode()
133			base_path = request.path
134			formats = []
135			for mode in export_modes.keys():
136			url = base_path
137			if query:
138			url += '?%s&format=%s' % (query, mode)
139			else:
140			url += '?format=%s' % (mode)
141			if append_query:
142			url += "&%s" % (append_query)
143			formats.append({'url': url, 'label': mode})
144
145			return {'formats': formats}
146
147
148			@register.inclusion_tag('metadataparser/export-menu.html')
149			def export_summary_menu(query):
150			formats = []
151			for mode in export_summary_modes.keys():
152			urlquery = {'format': mode,
153			'export': query}
154			url = "./?%(query)s" % {'query': urlencode(urlquery)}
155			formats.append({'url': url, 'label': mode})
156
157			return {'formats': formats}
158
159
160			@register.simple_tag()
161			def entities_count(entity_qs, entity_type=None):
162			if entity_type and entity_type != 'All':
163			return entity_qs.filter(types__xmlname=entity_type).count()
164			else:
165			return entity_qs.count()
166
167
168			@register.simple_tag()
169			def get_fed_total(totals, entity_type='All'):
170			tot_count = 0
171			for curtotal in totals:
172			if entity_type == 'All' or curtotal['types__xmlname'] == entity_type:
173			tot_count += curtotal['types__xmlname__count']
174			return tot_count
175
176
177			@register.simple_tag()
178			def get_fed_count(counts, federation='All', entity_type='All'):
179			count = counts[entity_type]
180
181			fed_count = 0
182			for curcount in count:
183			if federation == 'All' or curcount['federations__id'] == federation:
184			fed_count += curcount['federations__id__count']
185			return fed_count
186
187
188			@register.simple_tag(takes_context=True)
189			def l10n_property(context, prop, lang):
190			if isinstance(prop, dict) and len(prop) > 0:
191			if not lang:
192			lang = context.get('LANGUAGE_CODE', None)
193			if lang and lang in prop:
194			return prop.get(lang)
195			else:
196			return prop[prop.keys()[0]]
197			return prop
198
199
200
201			@register.simple_tag(takes_context=True)
202			def organization_property(context, organizations, prop, lang):
203			if not isinstance(organizations, list):
204			return prop
205
206			lang = lang or context.get('LANGUAGE_CODE', None)
207			for organization in organizations:
208			if prop in organization:
209			val = organization[prop]
210			if organization['lang'] == lang:
211			val = organization[prop]
212
213			return val
214
215
216			@register.simple_tag()
217			def get_property(obj, prop=None):
218			uprop = unicode(prop)
219			if not uprop:
220			return '<a href="%(link)s">%(name)s</a>' % {"link": obj.get_absolute_url(),
221			"name": unicode(obj),
222			}
223			if isinstance(obj, dict):
224			return obj.get(prop, None)
225			if getattr(getattr(obj, uprop, None), 'all', None):
226			return '. '.join(['<a href="%(link)s">%(name)s</a>' % {"link": item.get_absolute_url(),
227			"name": unicode(item)}
228			for item in getattr(obj, uprop).all()])
229			if isinstance(getattr(obj, uprop, ''), list):
230			return ', '.join(getattr(obj, uprop, []))
231			return getattr(obj, uprop, '')
232
233
234			@register.simple_tag(takes_context=True)
235			def active_url(context, pattern):
236			request = context.get('request')
237			if request.path == pattern:
238			return 'active'
239			return ''
240
241
242			@register.filter(name='display_etype')
243			def display_etype(value, separator=', '):
244			if isinstance(value, list):
245			return separator.join(value)
246			elif hasattr(value, 'all'):
247			return separator.join([unicode(item) for item in value.all()])
248			else:
249			if value in DESCRIPTOR_TYPES_DISPLAY:
250			return DESCRIPTOR_TYPES_DISPLAY.get(value)
251			else:
252			return value
253
254
255			@register.filter(name='wrap')
256			def wrap(value, length):
257			value = unicode(value)
258			if len(value) > length:
259			return "%s..." % value[:length]
260			return value
261
262
263			class CanEdit(Node):
264			child_nodelists = 'nodelist'
265
266			def __init__(self, obj, nodelist):
267			self.obj = obj
268			self.nodelist = nodelist
269
270			@classmethod
271			def __repr__(cls):
272			return "<CanEdit>"
273
274			def render(self, context):
275			obj = self.obj.resolve(context, True)
276			user = context.get('user')
277			if obj.can_edit(user, False):
278			return self.nodelist.render(context)
279			else:
280			return ''
281
282
283			def do_canedit(parser, token):
284			bits = list(token.split_contents())
285			if len(bits) != 2:
286			raise TemplateSyntaxError("%r takes 1 argument" % bits[0])
287			end_tag = 'end' + bits[0]
288			nodelist = parser.parse((end_tag,))
289			obj = parser.compile_filter(bits[1])
290			token = parser.next_token()
291			return CanEdit(obj, nodelist)
292
293
294			@register.tag
295			def canedit(parser, token):
296			"""
297			Outputs the contents of the block if user has edit pemission
298
299			Examples::
300
301			{% canedit obj %}
302			...
303			{% endcanedit %}
304			"""
305			return do_canedit(parser, token)
306
307			@register.filter
308			@stringfilter
309			def split(value, splitter='\|'):
310			if not isinstance(value, SafeData):
311			value = mark_safe(value)
312			return value.split(splitter)
313

GEANT / met

Push — master ( 28b0ba...17cdbf )

CanEdit.__init__() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

CanEdit.init() A