def render(self, name, value, attrs=None):
if value is None:
value = ''
final_attrs = self.build_attrs(attrs, type=self.input_type, name=name)
if value != '':
# Only add the 'value' attribute if a value is non-empty.
final_attrs['value'] = force_unicode(self._format_value(value))
return mark_safe(u"""<span class="currency"><span class="code">%s</span><span class="symbol">%s</span></span><input%s />""" % (self.currency[0],self.currency[1],flatatt(final_attrs)))
class FixedCurrency(DecimalField):
widget = CurrencyWidget
name = "Fixed Currency"
currency = ('USD','$')
def __init__(self, *args, **kwargs):
if 'currency' in kwargs:
self.currency = kwargs.pop('currency')
super(FixedCurrency,self).__init__(*args,**kwargs)
self.widget.currency = self.currency
def to_python(self, value):
if isinstance(value, basestring):
value = value.replace(' ','') #strip spaces
if len(value.split(',')[-1]) > 2:
value = value.replace(',','')
return super(FixedCurrency,self).to_python(value)
register.register('input','Currency field','fixed_currency', FixedCurrency)
from scorecard_processor.plugins import base, register
class Rating(base.ProcessPlugin):
name = 'Ratings'
argument_list = ['percentage']
input_type = base.Scalar
output_type = base.Scalar
def process(self):
value = self.get_arguments().percentage
if value == None:
output = ''
else:
value = value.get_value()
output = 'cross'
if value > 50:
output = 'dash'
if value > 80:
output = 'tick'
return self.output_type(output)
register.register('process','Rating','rating',Rating)
defaults = { 'value':'yes', 'match':'y', 'miss':'n' }
def process(self):
values = self.get_arguments().items.get_values()
if len(values) == 1:
if values[0].get_value().lower() == self.get_config('value'):
return self.output_type(self.get_config('match'))
return self.output_type(self.get_config('miss'))
else:
return None
class SingleValueInteger(SingleValue):
name = 'Validate single value (100 / 0)'
defaults = { 'value':'yes', 'match':100, 'miss':0 }
register.register('process','Assert value','assert_value_yn',SingleValue)
register.register('process','Assert value','assert_value_integer',SingleValueInteger)
class CombineValues(base.ProcessPlugin):
name = 'Combine Values'
argument_list = ['arg1','arg2']
input_type = base.Vector
output_type = base.Scalar
options = { 'value': basestring }
defaults = { 'value':'yes' }
def process(self):
output = []
for values in [self.get_arguments().arg1.get_values(), self.get_arguments().arg2.get_values()]:
for value in values:
if value.get_value():
else:
numerator = [float(x.get_calculated_value()) for x in self.get_arguments().numerator.get_values()]
denominator = [float(x.get_calculated_value()) for x in self.get_arguments().denominator.get_values()]
if numerator == [] or denominator == []:
return None
numerator = decimal.Decimal(str(reduce(sum_values, numerator)))
denominator = decimal.Decimal(str(reduce(sum_values, denominator)))
if denominator == 0:
return None
places = self.get_config('decimal_places')
if places>0:
quant = decimal.Decimal('.'.join(['1','0'*places]))
else:
quant = decimal.Decimal('1')
return self.output_type((100 * (
numerator /
denominator
)).quantize(quant))
class OneMinusNumDenomPlugin(NumDenomPlugin):
name = '100 - Divide(Sum(Argument 1), Sum(Argument 2))'
def process(self):
result = super(OneMinusNumDenomPlugin,self).process()
if result is not None:
return self.output_type(100 - result.get_values())
return result
register.register('process','Unweighted operations','num_denom',NumDenomPlugin)
register.register('process','Unweighted operations','one_minus_num_denom',OneMinusNumDenomPlugin)
from scorecard_processor.plugins import base, register
import decimal
class Sum(base.ProcessPlugin):
name = 'Sum items'
argument_list = ['items']
input_type = base.Vector
output_type = base.Scalar
def process(self):
values = []
for item in self.get_arguments().items.get_values():
value = item.get_value()
if value:
try:
values.append(decimal.Decimal(value))
except decimal.InvalidOperation:
pass
if len(values)>1:
return self.output_type(reduce(lambda x,y: x + y, values))
if len(values)==1:
return self.output_type(values[0])
return self.output_type(0)
register.register('process','Math','sum_items',Sum)
name = "Frequency of keyword (%)"
options = {
'value':basestring,
'decimal_places':int,
'ignore':list
}
defaults = {
'decimal_places':1,
'value':'yes',
'ignore':['n/a']
}
def process(self):
items = self.get_arguments().items.get_values()
count = len([item for item in items if item.get_value().lower() not in self.get_config('ignore')])
if count == 0:
return None
count_values = len(filter(lambda x: x.get_value().lower() == self.get_config('value'),items))
places = self.get_config('decimal_places')
if places>0:
quant = decimal.Decimal('.'.join(['1','0'*places]))
else:
quant = decimal.Decimal('1')
return self.output_type((decimal.Decimal(count_values) / count * 100).quantize(quant))
register.register('process','Count','count_items',Count)
register.register('process','Count','keyword_frequency',CountValue)
from scorecard_processor.plugins import base, register
def sum_values(x, y):
return x + y
class TextRenderer(base.Scalar):
def get_value(self):
return "\n\n".join([i[1] for i in self.value])
def _as_html(self):
if not self.value:
return ''
row = "<dt>%s</dt><dd>%s</dd>"
return "<dl class='concat'>%s</dl>" % ''.join([row % i for i in self.value])
class Concat(base.ProcessPlugin):
name = 'Concatenate responses'
argument_list = ['response']
input_type = base.Vector
output_type = TextRenderer
def process(self):
return self.output_type([(', '.join([v.response_set.entity.name]+[ds.name for ds in v.response_set.get_data_series()]), v.get_value()) for v in self.get_arguments().response.get_values()])
register.register('process','Text','concat',Concat)
from django.contrib.localflavor.generic.forms import DateField
from django.forms.extras.widgets import SelectDateWidget
from scorecard_processor.plugins import base, register
class DateSelectField(DateField):
widget = SelectDateWidget
name = "Date selector"
register.register("input", "Date field", "date", DateSelectField)
from django.forms import CharField, Textarea
from scorecard_processor.plugins import base, register
class TextBoxField(CharField):
widget = Textarea
name = "Long text field"
def widget_attrs(self, *args, **kwargs):
attrs = super(TextBoxField,self).widget_attrs(*args, **kwargs)
if not attrs:
attrs = {}
attrs['class'] = attrs.get('class','')+' xxlarge'
if 'rows' not in attrs:
attrs['rows'] = 3
return attrs
class TextField(CharField):
name = "Short text field"
register.register('input','Text field','text', TextField)
register.register('input','Text field','textbox', TextBoxField)
from django.forms import IntegerField
from django.forms.util import flatatt
from django.utils.safestring import mark_safe
from django.utils.encoding import StrAndUnicode, force_unicode
from scorecard_processor.plugins import base, register
class Integer(IntegerField):
name = "Integer"
register.register('input','Number','integer', Integer)
class YesNoField(ChoiceField):
name = "Yes / No choice"
def __init__(self, *args, **kwargs):
super(YesNoField,self).__init__(*args,**kwargs)
self.choices = (
('',''),
('yes',_('Yes')),
('no',_('No')),
)
class Rating(ChoiceField):
r_min = 0
r_max = 5
step = 0.5
name = "Rating: %s - %s (step: %s)" % (r_min, r_max, step)
def __init__(self, *args, **kwargs):
super(Rating,self).__init__(*args,**kwargs)
self.choices = tuple([(x*self.step, x*self.step) for x in range(self.r_min, int(self.r_max / self.step)+1)])
class RatingInt(Rating):
step=1
r_min = 0
r_max = 5
name = "Rating: %s - %s (step: %s)" % (r_min, r_max, step)
register.register('input','Choice field','yes_no_choice', YesNoField)
register.register('input','Choice field','yes_no_na_choice', YesNoNAField)
register.register('input','Choice field','rating_0_5_half', Rating)
register.register('input','Choice field','rating_0_5', RatingInt)
