def render(self, djp, wrapper, prefix, for_user = False, **kwargs):
instance = djp.instance
request = djp.request
appmodel = None
items = None
if for_user:
user = request.user
try:
trader = user.trader
appmodel = appsite.site.for_model(Fund)
items = trader.fund_holder.funds.filter(parent = None)
except:
pass
else:
if not instance:
appmodel = appsite.site.for_model(FundHolder)
items = FundHolder.objects.filter(fund_manager = True)
elif isinstance(instance,FundHolder):
appmodel = appsite.site.for_model(Fund)
items = instance.funds.filter(parent = None)
elif isinstance(instance,Fund):
appmodel = appsite.site.for_model(Fund)
items = instance.views.all()
if items and appmodel:
cts = []
for item in items:
url = appmodel.viewurl(request,item)
cts.append({'url':url,
'name':item_description(item)})
return loader.render_to_string('trade/team_list.html', {'items': cts})
return u''
def render(self, djp = None, validate = False):
'''Render the uniform by rendering individual forms, inline forms and inputs.'''
fdict = {}
forms = []
num = 0
inputs = self.render_inputs()
for layout,form in self.forms:
num += 1
html = layout.render(form, inputs)
forms.append(html)
fdict['html%s' % num] = html
cd = {'uniform': self,
'errors': self._errors or '',
'forms': forms,
'fdict': fdict,
'inputs': inputs,
'inlines': self.render_inlines()}
context_instance = None
if djp:
context_instance = RequestContext(djp.request, cd)
cd = None
djp.media += self.media
if validate:
self.is_valid()
return loader.render_to_string(self.template,cd,
context_instance)
def render(self, form, inputs = None):
'''Render the uniform layout or *form*.'''
ctx = {}
html = ''
for field in self._allfields:
h = field.render(form, self)
if field.key and self.template:
ctx[field.key] = h
else:
html += h
missing_fields = []
rendered_fields = get_rendered_fields(form)
for field in form.fields.keys():
if not field in rendered_fields:
missing_fields.append(field)
if missing_fields:
fset = Fieldset(*missing_fields,**{'css_class':self.default_style})
html += fset.render(form,self)
if ctx:
ctx['inputs'] = inputs
ctx['html'] = mark_safe(html)
html = loader.render_to_string(self.template, ctx)
else:
html = mark_safe(html)
if self.id:
return mark_safe('<div id="%s">%s</div>' % (self.id,html))
else:
return html
def render_inlines(self):
if self.formsets:
return loader.render_to_string('djpcms/uniforms/inlines.html',
{'form_inlines': self.formsets,
'field_class': inlineFormsets})
else:
return ''
def render(self, djp, wrapper, prefix,
for_model = None, steps = 4, min_count = None, **kwargs):
try:
formodel = ContentType.objects.get(id = int(for_model)).model_class()
except:
return u''
steps = int(steps)
if min_count:
min_count = int(min_count)
site = get_site(djp.request.path)
appmodel = site.for_model(formodel)
tags = self.get_tags(**kwargs)
if tags:
query = TaggedItem.objects.get_by_model(formodel,tags)
query = self.model.objects.usage_for_queryset(query, counts=True)
tags = calculate_cloud(query)
else:
tags = Tag.objects.cloud_for_model(formodel,
steps = steps,
min_count = min_count)
request = djp.request
for tag in tags:
try:
tag.url = appmodel.tagurl(request, tag.name)
except:
tag.url = None
if tag.count == 1:
tag.times = 'time'
else:
tag.times = 'times'
c = {'tags': tags}
return loader.render_to_string(['bits/tag_cloud.html',
'djpcms/bits/tag_cloud.html'],c)
def render(self, djp, wrapper, prefix, for_user=False, **kwargs):
instance = djp.instance
request = djp.request
appmodel = None
items = None
if for_user:
user = request.user
try:
trader = user.trader
appmodel = appsite.site.for_model(Fund)
items = trader.fund_holder.funds.filter(parent=None)
except:
pass
else:
if not instance:
appmodel = appsite.site.for_model(FundHolder)
items = FundHolder.objects.filter(fund_manager=True)
elif isinstance(instance, FundHolder):
appmodel = appsite.site.for_model(Fund)
items = instance.funds.filter(parent=None)
elif isinstance(instance, Fund):
appmodel = appsite.site.for_model(Fund)
items = instance.views.all()
if items and appmodel:
cts = []
for item in items:
url = appmodel.viewurl(request, item)
cts.append({'url': url, 'name': item_description(item)})
return loader.render_to_string('trade/team_list.html',
{'items': cts})
return u''
def render(self, djp, wrapper, prefix, for_model=None, method="get", title=None, **kwargs):
if for_model:
site = get_site()
try:
ct = ContentType.objects.get(id=int(for_model))
except:
raise ValueError("Content type %s not available" % for_model)
model = ct.model_class()
request = djp.request
appmodel = site.for_model(model)
if appmodel:
search_url = appmodel.searchurl(request)
if search_url:
data = request.GET if method == "get" else request.POST
# prefix = data.get("_prefixed",None)
# if not prefix:
# prefix = gen_unique_id()
prefix = None
f = SearchForm(data=data, prefix=prefix)
if title:
f.fields["q"].widget.attrs["title"] = title
return loader.render_to_string(
["search_form.html", "bits/search_form.html", "djpcms/bits/search_form.html"],
{
"html": f,
"prefix": prefix,
"title": title or "Enter your search term",
"url": search_url,
"method": method,
},
)
else:
raise ValueError("Content type not available")
def render(self, djp, wrapper, prefix, layout="horizontal", asbuttons=True, exclude="", **kwargs):
try:
exclude = exclude.split(",")
links = djp.view.appmodel.links(djp, asbuttons=asbuttons, exclude=exclude)
links["layout"] = layout
return loader.render_to_string(["bits/editlinks.html", "djpcms/bits/editlinks.html"], links)
except:
return u""
def render(self, djp, wrapper, prefix, **kwargs):
ops = operators.all()
rops = []
for op in ops.values():
rops.append({'operator': op.__name__,
'fullname': op.fullname,
'description': op.__doc__})
return loader.render_to_string('instdata/operators.html', {'items': rops})
def paginator(self, djp, qs):
from djpcms.views import appsite
appmodel = appsite.site.for_model(Category)
for obj in qs:
if appmodel:
content = appmodel.object_content(djp, obj)
yield loader.render_to_string(['category_list_item.html',
'components/category_list_item.html',
'flowrepo/category_list_item.html'],
content)
def render_object(self, djp, wrapper=None):
"""
Render an object.
This is usually called in the view page of the object
"""
obj = djp.instance
request = djp.request
template_name = self.get_object_view_template(obj, wrapper or djp.wrapper)
content = self.object_content(djp, obj)
return loader.render_to_string(template_name, content)
def _render(self, form, layout):
css = self._css(layout)
content = {}
for i,column in enumerate(self.columns):
output = u'<div class="%s">' % css
for field in column:
output += render_field(field, form, layout, self.css)
output += u'</div>'
content['content%s' % i] = mark_safe(output)
return loader.render_to_string(self.template, content)
def render(self, djp, wrapper, prefix, **kwargs):
ops = operators.all()
rops = []
for op in ops.values():
rops.append({
'operator': op.__name__,
'fullname': op.fullname,
'description': op.__doc__
})
return loader.render_to_string('instdata/operators.html',
{'items': rops})
def render(self, djp, wrapper, prefix, category_name = None, **kwargs):
if category_name:
qs = Category.objects.filter(type__id = int(category_name))
else:
return u''
if not qs:
return u''
return loader.render_to_string(['category_list.html',
'components/category_list.html',
'flowrepo/category_list.html'],
{'items': self.paginator(djp,qs)})
def render(self, djp, wrapper, prefix, layout="horizontal", asbuttons=True, exclude="", **kwargs):
try:
exclude = exclude.split(",")
links = djp.view.appmodel.object_links(djp, djp.instance, asbuttons=asbuttons, exclude=exclude)
links["layout"] = layout
if links["geturls"] or links["posturls"]:
return loader.render_to_string(["bits/editlinks.html", "djpcms/bits/editlinks.html"], links)
else:
return u""
except:
return u""
def render(self, djp, wrapper, prefix, **kwargs):
from djpcms.views import appsite
instance = djp.instance
if not isinstance(instance,FlowItem):
return
qs = FlowRelated.objects.filter(item = instance)
if not qs:
return
request = djp.request
return loader.render_to_string(['report_draft_list.html',
'flowrepo/report_draft_list.html'],
{'items': self.paginator(djp,qs)})
def data_generator(self, djp, data):
"""
Return a generator for the query.
This function can be overritten by derived classes
"""
request = djp.request
wrapper = djp.wrapper
prefix = djp.prefix
app = self
for obj in data:
content = app.object_content(djp, obj)
yield loader.render_to_string(self.get_item_template(obj, wrapper), content)
def extra_content(self, djp, c):
page = djp.page
request = djp.request
page_url = self.page_url(djp.request)
ed = {
'page_form': get_form(djp, ShortPageForm, instance = page, withinputs=True).render(djp,validate=True),
'new_child_form': get_form(djp, NewChildForm, instance = page, withinputs=True).render(djp,validate=True),
'page_url': self.page_url(djp.request)}
bd = loader.render_to_string(self.edit_template,ed)
c.update({'page_url':page_url,
'edit_page':box(hd = "Edit Page Layout",
bd = bd,
collapsed=True)})
def render(self, djp, wrapper, prefix, **kwargs):
'''
Information about the packages used to power the web-site
'''
v = version.get()
p = v.pop('python')
d = v.pop('django')
c = {'python': p.get('version'),
'django': d.get('version'),
'other': v.values()}
return loader.render_to_string(['/bits/powered_by.html',
'djpcms/bits/powered_by.html'],
c)
def render(self,
djp,
wrapper,
prefix,
server='localhost',
port=6379,
db=0,
**kwargs):
r = redis.Redis(host=server, port=port, db=db)
info = r.info()
info1 = []
info2 = []
model_info = []
keys = 0
for k in info:
if k[:2] == 'db':
num = getint(k[2:])
if num is not None:
data = info[k]
keydb = data['keys']
data['keys'] = format_number(keydb)
niceadd(info2, 'database %s' % num,
'keys %(keys)s, expires %(expires)s' % data)
keys += keydb
niceadd(info1, 'Redis version', info['redis_version'])
niceadd(info1, 'Process id', info['process_id'])
niceadd(info1, 'Total keys', format_number(keys))
niceadd(info1, 'Memory used', info['used_memory_human'])
niceadd(info1, 'Up time', nicetimedelta(info['uptime_in_seconds']))
niceadd(info1, 'Virtual Memory enabled',
'yes' if info['vm_enabled'] else 'no')
niceadd(info1, 'Last save', nicedate(info['last_save_time']))
niceadd(info1, 'Commands processed',
format_number(info['total_commands_processed']))
niceadd(info1, 'Connections received',
format_number(info['total_connections_received']))
model_header = ['name', 'db', 'base key']
for model in orm.mapper._registry:
meta = model._meta
cursor = meta.cursor
if cursor.name == 'redis':
model_info.append([meta, cursor.db, meta.basekey()])
return loader.render_to_string(
'monitor/redis_monitor.html', {
'info1': info1,
'info2': info2,
'model_header': model_header,
'model_info': model_info
})
def render(self, djp, wrapper, prefix, api_url = '.', height = 0, **kwargs):
height = abs(int(height or 0))
instance = djp.instance
request = djp.request
obj = pyapi.get_portfolio_object(instance, request.user)
id = finins.get_object_id(obj,datetime.date.today())
options = {}
ctx = {'url': api_url,
'id': id,
'options': options,
'fields': mark_safe(json.dumps(finins.fields()))}
if height:
options['height'] = height
return loader.render_to_string('trade/portfolio-application.html', ctx)
def render(self, djp, wrapper, prefix, content_types = None, display = 'list', inverse = False, **kwargs):
from djpcms.views import appsite
instance = djp.instance
if not isinstance(instance,FlowItem):
return
qs = instance.items.all()
lqs = list(qs)
if content_types:
qs = qs.filter(content_type__id__in = content_types)
if not qs:
return ''
request = djp.request
return loader.render_to_string(['report_draft_list.html',
'flowrepo/related_list.html'],
{'items': self.paginator(djp,wrapper,qs,display)})
def totable(self, obj):
'''Render an object as definition list.'''
label_for_field = self.label_for_field
getrepr = self.getrepr
def data():
for field in self.object_display:
name = label_for_field(field)
yield {'name':name,'value':getrepr(field,obj)}
content = {'module_name':self.module_name,
'id':self.get_object_id(obj),
'data':data(),
'item':obj}
return loader.render_to_string(['%s/%s_table.html' % (self.app_label,self.module_name),
'djpcms/components/object_definition.html'],
content)
def paginator(self, djp, pa):
site = get_site()
appmodel = site.for_model(FlowItem)
qs = pa.qs
for obj in qs:
object = obj.object
model = object.__class__
objmodel = site.for_model(model) or appmodel
if objmodel:
content = objmodel.object_content(djp, obj)
tname = '%s_list_item.html' % model.__name__.lower()
yield loader.render_to_string(['components/%s' % tname,
'flowrepo/%s' % tname,
'flowrepo/flowitem_list_item.html'],
content)
def render(self, djp, wrapper, prefix,
visibility = None, item_per_page = 10,
content_type = None, tags = '',
**kwargs):
request = djp.request
qs = FlowItem.objects.selection(request.user,
types = content_type,
visibility = visibility,
tags = tags)
if not qs:
return None
pa = Paginator(djp.request, qs, item_per_page)
return loader.render_to_string(['flowitem_list.html',
'djpcms/components/object_list.html'],
{'items': self.paginator(djp,pa)})
def render(self, djp, wrapper, prefix, **kwargs):
from djpcms.conf import settings
from djpcms.utils import timezone
if 'djpcms.contrib.jdep' in settings.INSTALLED_APPS:
from djpcms.contrib.jdep.models import DeploySite
try:
latest = DeploySite.objects.latest()
except:
return ''
return loader.render_to_string(['/bits/deploy.html',
'djpcms/bits/deploy.html'],
{'latest':latest,
'name': timezone.tzname(dt = latest.created),
'url': timezone.link()})
else:
return ''
def render(self, djp, wrapper, prefix, api_url='.', height=0, **kwargs):
height = abs(int(height or 0))
instance = djp.instance
request = djp.request
obj = pyapi.get_portfolio_object(instance, request.user)
id = finins.get_object_id(obj, datetime.date.today())
options = {}
ctx = {
'url': api_url,
'id': id,
'options': options,
'fields': mark_safe(json.dumps(finins.fields()))
}
if height:
options['height'] = height
return loader.render_to_string('trade/portfolio-application.html', ctx)
def render(self, djp, wrapper, prefix, **kwargs):
instance = djp.instance
if isinstance(instance, DataId):
vids = instance.vendors.all()
cts = []
for v in vids:
vendor = v.vendor
vi = vendor.interface()
tk = v.ticker
if vi:
url = vi.weblink(tk)
cts.append({"url": url, "vendor": v.vendor, "ticker": v.ticker})
return loader.render_to_string("instdata/dataid_vendors.html", {"items": cts})
else:
return u""
def render_form_field(field, form, layout, css_class):
try:
field_instance = form.fields[field]
except KeyError:
raise Exception("Could not resolve form field '%s'." % field)
bound_field = BoundField(form, field_instance, field)
label = None if css_class == nolabel else bound_field.label
html = loader.render_to_string("djpcms/uniforms/field.html",
{'field': bound_field,
'label': label,
'required': _required_tag})
rendered_fields = get_rendered_fields(form)
if not field in rendered_fields:
rendered_fields.append(field)
else:
raise Exception("A field should only be rendered once: %s" % field)
return html
def config_file(fname, environ=None, dir = None):
'''Create a configuration file from template and return the filename
* *fname*: The template used to create the file
* *dir*: directory containing the file or None. If none no file will be saved.
'''
template = os.path.join('jdep',fname)
data = loader.render_to_string(template,environ)
if dir:
filename = config_file_name(fname, environ)
fullpath = os.path.join(dir,filename)
f = open(fullpath,'w')
f.write(data)
f.close()
return filename
else:
return data
def render(self, djp, wrapper, prefix, for_model=None, max_display=5, pagination=False, **kwargs):
try:
site = djp.site
ct = ContentType.objects.get(id=for_model)
model = ct.model_class()
appmodel = site.for_model(model)
if not appmodel:
return ""
except:
return ""
data = appmodel.orderquery(appmodel.basequery(djp))
max_display = max(max_display, 1)
items = data[0:max_display]
if not items:
return ""
templates = self.get_templates(appmodel.opts, "list")
content = {"items": self.datagen(appmodel, djp, wrapper, items)}
return loader.render_to_string(templates, content)
def render(self, name, value, attrs=None):
attrs = attrs or {}
if value:
key = self.search_fields[0].split('__')[0]
obj = self.model.objects.get(pk = value)
label = getattr(obj,key)
else:
label = u''
ctx = {'name': name,
'value': value,
'label': label,
'url': self.get_url(),
'id': attrs.get('id',''),
'widget_class': self.attrs.pop('class',''),
'css': sites.settings.HTML_CLASSES}
return loader.render_to_string('djpcms/autocomplete/single.html',ctx)
def render(self, djp):
app = self.appmodel
request = djp.request
args = djp.kwargs
page = djp.page
lang = args.get("lang", app.deflang)
version = args.get("version", app.defversion)
url = args.get("url", "")
docroot = self.appmodel.get_docroot(lang, version)
# First look for <bits>/index.fpickle, then for <bits>.fpickle
bits = url.strip("/").split("/") + ["%s.fjson" % app.master_doc]
doc = docroot.child(*bits)
if not doc.exists():
bits = bits[:-2] + ["%s.fjson" % bits[-2]]
doc = docroot.child(*bits)
if not doc.exists():
raise http.Http404("'%s' does not exist" % doc)
bits[-1] = bits[-1].replace(".fjson", "")
name = self.appmodel.name
namet = "-".join([b for b in bits if b])
namet = app.name_template_mapping.get(namet, namet)
template_names = ["docs/%s.html" % namet, "djpcms/docs/%s.html" % namet, "docs/doc.html"]
doc = json.load(open(doc, "rb"))
rels = []
for link in doc.get("rellinks", []):
rels.append({"url": "%s%s/" % (app.baseurl, link[0]), "title": link[1]})
doc["rellinks"] = rels
djp.breadcrumbs = self.makebreadcrumbs(djp, doc)
c = {
"doc": doc,
"env": json.load(open(docroot.child("globalcontext.json"), "rb")),
"lang": lang,
"version": version,
"docurl": url,
"update_date": datetime.datetime.fromtimestamp(docroot.child("last_build").mtime()),
#'home': urlresolvers.reverse('document-index', kwargs={'lang':lang, 'version':version}),
#'search': urlresolvers.reverse('document-search', kwargs={'lang':lang, 'version':version}),
"redirect_from": request.GET.get("from", None),
}
return loader.render_to_string(template_names, c)
def render(self, djp, wrapper, prefix,
server = 'localhost',
port = 6379,
db = 0,
**kwargs):
r = redis.Redis(host = server, port = port, db = db)
info = r.info()
info1 = []
info2 = []
model_info = []
keys = 0
for k in info:
if k[:2] == 'db':
num = getint(k[2:])
if num is not None:
data = info[k]
keydb = data['keys']
data['keys'] = format_number(keydb)
niceadd(info2, 'database %s' % num, 'keys %(keys)s, expires %(expires)s' % data)
keys += keydb
niceadd(info1, 'Redis version', info['redis_version'])
niceadd(info1, 'Process id', info['process_id'])
niceadd(info1, 'Total keys', format_number(keys))
niceadd(info1, 'Memory used', info['used_memory_human'])
niceadd(info1, 'Up time', nicetimedelta(info['uptime_in_seconds']))
niceadd(info1, 'Virtual Memory enabled', 'yes' if info['vm_enabled'] else 'no')
niceadd(info1, 'Last save', nicedate(info['last_save_time']))
niceadd(info1, 'Commands processed', format_number(info['total_commands_processed']))
niceadd(info1, 'Connections received', format_number(info['total_connections_received']))
model_header = ['name','db','base key']
for model in orm.mapper._registry:
meta = model._meta
cursor = meta.cursor
if cursor.name == 'redis':
model_info.append([meta, cursor.db, meta.basekey()])
return loader.render_to_string('monitor/redis_monitor.html',
{'info1':info1,
'info2':info2,
'model_header':model_header,
'model_info':model_info})
def render(self, djp, wrapper, prefix, **kwargs):
instance = djp.instance
if isinstance(instance, DataId):
vids = instance.vendors.all()
cts = []
for v in vids:
vendor = v.vendor
vi = vendor.interface()
tk = v.ticker
if vi:
url = vi.weblink(tk)
cts.append({
'url': url,
'vendor': v.vendor,
'ticker': v.ticker
})
return loader.render_to_string('instdata/dataid_vendors.html',
{'items': cts})
else:
return u''
