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_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 clean_for_model(self):
site = get_site()
ct = self.cleaned_data["for_model"]
model = ct.model_class()
appmodel = site.for_model(model)
if appmodel:
return ct
else:
raise forms.ValidationError("Model %s has no application installed" % ct)
def registered_models(url=None):
ids = []
site = get_site(url)
for model, app in site._registry.items():
if isinstance(app, site.ModelApplication) and not app.hidden:
try:
ct = ContentType.objects.get_for_model(model)
except:
continue
ids.append(ct.id)
return ContentType.objects.filter(pk__in=ids)
def setup(self):
settings = djpcms.get_site().settings
cfgdir = settings.SITE_DIRECTORY
srcdir = os.path.join(settings.SITE_DIRECTORY,'flowtmp')
outdir = os.path.join(settings.MEDIA_ROOT,'site')
if not os.path.exists(outdir):
os.mkdir(outdir)
if not os.path.exists(srcdir):
os.mkdir(srcdir)
self.srcdir = srcdir
self.cfgdir = cfgdir
self.outdir = outdir
self.media_url = '{0}site/'.format(settings.MEDIA_URL)
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 clean_application_view(self):
'''If application type is specified, than it must be unique
'''
site = get_site()
data = self.data
app = data.get('application_view',None)
if app:
try:
application_view = site.getapp(app)
except KeyError:
raise forms.ValidationError('Application view %s not available' % app)
parent = self.get_parent()
# Parent page is available
if parent:
if not application_view.parent:
parent = None
self.data.pop('parent',None)
elif application_view.parent.code != parent.application_view:
raise forms.ValidationError("Page %s is not a parent of %s" % (parent,application_view))
bit = data.get('url_pattern','')
if not application_view.regex.names:
data['url_pattern'] = ''
bit = ''
elif parent and application_view.parent:
if parent.application_view == application_view.parent.code and parent.url_pattern:
bit = parent.url_pattern
data['url_pattern'] = bit
others = Page.objects.filter(application_view = application_view.code,
site = self.clean_site(),
url_pattern = bit)
for other in others:
if other != self.instance:
raise forms.ValidationError('Application page %s already avaiable' % app)
else:
parent = self.get_parent()
if not parent:
# No parent specified. Let's check that a root is not available
root = Page.objects.root(self.clean_site())
if root and root != self.instance:
# We assume the page to be child of root. Lets check it is not already avialble
self.data['parent'] = root.id
#raise forms.ValidationError('Page root already avaiable')
return app
def app_model_from_ct(ct, url=None):
if ct:
site = get_site(url)
if not isinstance(ct, ContentType):
try:
ct = ContentType.objects.get(id=int(ct))
except:
if site.settings.DEBUG:
return "Content type %s not available" % ct, False
else:
return "", False
model = ct.model_class()
appmodel = site.for_model(model)
if appmodel:
return appmodel, True
else:
return "", False
else:
return "", False
def absolute_path(self, path):
if path.startswith(u'http://') or path.startswith(u'https://') or path.startswith(u'/'):
return path
# We don'have a path. Lets get the global site
site = get_site()
return urljoin(site.settings.MEDIA_URL,path)
def objtable(obj):
appmodel = get_site().for_model(obj.__class__)
if appmodel:
return appmodel.opts.totable(obj)
else:
return obj
def CalculatePageUrl(data, page):
'''Calculate url for a page'''
site = get_site()
application_view = data.get('application_view','')
url_pattern = data.get('url_pattern','')
parent = data['parent']
website = data['site']
if application_view:
app = site.getapp(application_view)
if not app:
raise ValueError("Application view %s not available on site." % application_view)
data['application_view'] = app.code
page.application = app.appmodel.name
purl = app.urlbit.url
if app.isroot():
url = app.baseurl
root = Page.objects.filter(site = website, level = 0)
if url == '/':
if root:
root = root[0]
if root != page:
raise forms.ValidationError("Root page already available, cannot set application as root. Delete the flat root page first")
parent = None
else:
url = url[1:-1]
urls = url.split('/')
if len(urls) > 1:
url = urls[-1]
parent_url = '/%s/' % '/'.join(urls[:-1])
root = Page.objects.filter(site = website, url = parent_url)
else:
parent_url = '/'
if root:
parent = root[0]
else:
raise forms.ValidationError('Parent page "%s" not available, cannot set application %s' % (parent_url,application_view))
else:
if not parent:
pages = Page.objects.filter(application_view = app.parent.code,
site = website,
url_pattern = '')
if pages.count() == 1:
parent = pages[0]
else:
raise forms.ValidationError('Parent page not defined for %s' % app.code)
bit = url_pattern
if bit and app.regex.names and parent.url_pattern != bit:
bits = bit.split('/')
kwargs = dict(zip(app.regex.names,bits))
purl = app.regex.get_url(**kwargs)
url = purl
else:
page.application = ''
url = url_pattern
data['parent'] = parent
if parent:
url = '%s%s' % (parent.url,url)
if not url.endswith('/'):
url += '/'
if not url.startswith('/'):
url = '/%s' % url
return url
def siteapp_choices():
return get_site().choices
