def data_generator(self, djp, data):
'''
Modify the standard data generation method so that links to date archive are generated
'''
request = djp.request
prefix = djp.prefix
wrapper = djp.wrapper
date = None
for obj in data:
content = self.object_content(djp, obj)
dt = getattr(obj,self.date_code)
ddate = dt.date()
if self.split_days and (not date or date != ddate):
urlargs = djp.kwargs.copy()
urlargs.pop('year',None)
urlargs.pop('month',None)
urlargs.pop('day',None)
content['year'] = {'url': self.yearurl(request,dt.year,**urlargs),
'value': dt.year}
content['month'] = {'url': self.monthurl(request,dt.year,dt.month,**urlargs),
'value': force_str(MONTHS[dt.month])}
content['day'] = {'url': self.dayurl(request,dt.year,dt.month,dt.day,**urlargs),
'value': dt.day}
content['wday'] = force_str(WEEKDAYS_ABBR[dt.weekday()])
date = ddate
yield loader.render_to_string(template_name = self.get_item_template(obj, wrapper),
context_instance = Context(content))
def __init__(self, parent_model, model, legend = None, **kwargs):
self.parent_model = parent_model
self.model = model
if legend is not False:
legend = legend or force_str(model._meta.verbose_name_plural)
self.legend = mark_safe('' if not legend else '<legend>'+legend+'</legend>')
self.FormSet = inlineformset_factory(parent_model, model, **kwargs)
def tojson(self, autoescape = True):
t = handle()
try:
s = force_str(self.dumps())
return s if not autoescape else t.mark_safe(s)
except Exception as e:
return self.handleError(e, autoescape)
def _getrepr(self, name, instance):
try:
f, attr, value = lookup_field(name, instance, self.model_admin)
except (AttributeError, ObjectDoesNotExist):
result_repr = self.get_value(instance, name, sites.settings.DJPCMS_EMPTY_VALUE)
else:
if f is None:
allow_tags = getattr(attr, 'allow_tags', False)
boolean = getattr(attr, 'boolean', False)
if boolean:
allow_tags = True
result_repr = _boolean_icon(value)
else:
result_repr = force_str(value)
# Strip HTML tags in the resulting text, except if the
# function has an "allow_tags" attribute set to True.
if not allow_tags:
result_repr = escape(result_repr)
else:
result_repr = mark_safe(result_repr)
else:
if value is None:
result_repr = sites.settings.DJPCMS_EMPTY_VALUE
if isinstance(f.rel, models.ManyToOneRel):
result_repr = escape(getattr(instance, f.name))
else:
result_repr = display_for_field(value, f)
return result_repr
def result_for_item(self, headers, result, djp, nd = 3):
if isinstance(result, self.model):
request = djp.request
path = djp.http.path_with_query(request)
first = True
id = ('%s-%s') % (self.module_name,result.id)
display = []
item = {'id':id,'display':display}
for field_name in headers:
result_repr = self.getrepr(field_name, result, nd)
if force_str(result_repr) == '':
result_repr = mark_safe(' ')
if (first and not self.list_display_links) or field_name in self.list_display_links:
first = False
url = self.url_for_result(request, result, field_name)
else:
url = None
var = conditional_escape(result_repr)
if url:
if url != path:
var = mark_safe('<a href="{0}" title="{1}">{1}</a>'.format(url, var))
else:
var = mark_safe('<a>{0}</a>'.format(var))
display.append(var)
return item
else:
return nice_items_id(result, nd = nd)
def success_message(instance, mch):
dt = datetime.now()
c = {'dt': format(dt,sites.settings.DATETIME_FORMAT),
'mch': mch,
'obj': instance}
if instance:
c['name'] = force_str(instance._meta.verbose_name)
return _('The %(name)s "%(obj)s" was succesfully %(mch)s %(dt)s') % c
else:
return _('%(mch)s %(dt)s') % c
def htmlbody(self):
text = self.body
if not text:
return ''
mkp = markuplib.get(self.markup)
if mkp:
handler = mkp.get('handler')
text = handler(text)
text = mark_safe(force_str(text))
return text
def fields(self):
formset = self.formset
form = formset.form
fk = getattr(formset, "fk", None)
for name,field in formset.form.base_fields.items():
if fk and fk.name == name:
continue
#bound_field = BoundField(form, field, name)
if field.label is None:
field.label = force_str(name.replace('_',' '))
yield field
def render(self):
'''Render the Block by looping over all the content block items
'''
edit = '' if not self.view.editurl else 'sortable-block '
id = block_htmlid(self.page.id,self.b)
html = ['<div id="{0}" class="{1}djpcms-block">'.format(id,edit)]
for ht in self.blocks():
if ht:
html.append(ht)
html.append('%s</div>' % self.empty())
return mark_safe(force_str('\n'.join(html)))
def resolve(self, path):
tried = []
match = self.regex.search(path)
if match:
new_path = path[match.end():]
for pattern in self.url_patterns:
try:
sub_match = pattern.resolve(new_path)
except Resolver404, e:
sub_tried = e.args[0].get('tried')
if sub_tried is not None:
tried.extend([(pattern.regex.pattern + ' ' + t) for t in sub_tried])
else:
tried.append(pattern.regex.pattern)
else:
if sub_match:
sub_match_dict = dict([(force_str(k), v) for k, v in match.groupdict().items()])
sub_match_dict.update(self.default_kwargs)
for k, v in sub_match[2].iteritems():
sub_match_dict[force_str(k)] = v
return sub_match[0], sub_match[1], sub_match_dict
tried.append(pattern.regex.pattern)
raise Resolver404({'tried': tried, 'path': new_path})
def nicefield(model, name):
opts = model._meta
try:
label = force_str(opts.get_field_by_name(name)[0].verbose_name)
except models.FieldDoesNotExist:
if name == "__str__":
label = force_str(opts.verbose_name)
elif hasattr(model, name):
attr = getattr(model, name)
else:
message = "Unable to lookup '%s' on %s" % (name, opts.object_name)
raise AttributeError(message)
if attr:
if hasattr(attr, "short_description"):
label = attr.short_description
elif callable(attr):
if attr.__name__ == "<lambda>":
label = "--"
else:
label = attr.__name__
else:
label = name
return label
def clean_url_pattern(self):
'''
Check for url patterns
No need if:
1 - it is the root page
2 - oit is an application page
Otherwise it is required
'''
data = self.data
value = data.get('url_pattern',None)
if value:
value = slugify(force_str(value))
if data.get('application_view',None):
return value
parent = self.get_parent()
if parent:
if not value:
raise forms.ValidationError('url_pattern or application view must be provided if not a root page')
page = parent.children.filter(url_pattern = value)
if page and page[0].id != self.instance.id:
raise forms.ValidationError("page %s already available" % page)
return value
def title(self, djp):
m = self.appmodel.get_month_number(djp.getdata('month'))
return force_str(MONTHS[m])
def test_force_str(self):
ts = bytes('test string')
self.assertEqual(force_str(ts),stringtype('test string'))
def handleError(self, e, autoescape = True):
t = handle()
s = force_str(e)
return s if not autoescape else t.mark_safe(s)
def get_month_value(self, month):
return force_str(MONTHS_3.get(month))
def handleError(self, e):
js = self._dump(self._dict('server-error', e))
return mark_safe(force_str(js))
def _get_permission(self, obj, code, create = False):
ct = ContentType.objects.get_for_model(obj)
pe = Permission.objects.filter(codename = code, content_type = ct)
if pe:
pe = pe[0]
elif create:
pe = Permission(codename = code, content_type = ct, name = 'Can view %s' % force_str(obj._meta.verbose_name))
pe.save()
return pe
