class PluginConfig(Plugin):
name = 'File browser'
description = 'File browser plugin'
version = '0.0.1a'
config_params = [
params.Single(name='filebrowser_root',
label=_('Root below MEDIA_ROOT'),
default='filebrowser'),
params.Single(name='filebrowser_docs_root',
label=_('Docs root below MEDIA_ROOT'),
default='filebrowser_docs'),
params.Single(name='filebrowser_docs_url',
label=_('Docs url below MEDIA_URL'),
default='filebrowser_docs/'),
]
url_prefixes = (({
'en': 'filebrowser',
'es': 'navegador_de_ficheros'
}, 'plugins.filebrowser.urls'), )
def models(self):
return [(Repository, RepositoryModelAdmin),
(Document, DocumentModelAdmin)]
def section_models(self):
return [(Repository, RepositorySectionModelAdmin)]
def get_blocks(self):
return [LatestFilesBlock]
class PluginConfig(Plugin):
name = 'ContactForm'
description = 'ContactForm plugin'
version = '0.0.1'
url_prefixes = (({
'en': 'contactform',
'es': 'formulario_de_contacto'
}, 'plugins.contactform.urls'), )
config_params = [
params.Single(name='rpubk',
label=_('recaptcha public key'),
default='6LegA8ASAAAAAF9AhuaPUPYb94p3vE4IkHOxfgAi'),
params.Single(name='rprivk',
label=_('recaptcha private key'),
default='6LegA8ASAAAAAAI-nxu0DcCdDCQIzuWCNbKOXPw3'),
]
def get_blocks(self):
return [ContactFormBlock]
def get_model_admins(self):
return [(ContactForm, ContactFormAdmin),
(SentContactForm, SentContactFormAdmin)]
def models(self):
return [(ContactForm, ContactFormAdmin),
(SentContactForm, SentContactFormAdmin)]
class GoogleAnalyticsBlock(Block):
name = 'map'
default_place = 'meta'
help_text = _('Block that includes the javascript needed to enable google analytics')
verbose_name = _('Google Analytics Block')
config_params = BaseBlock.config_params + [
params.Single(
name="google_analytics_id",
label=_("google analytics id"),
default='',
),
params.Single(
name="web_master_tools_id",
label=_("Web master tools id"),
default='',
),
]
def render(self, request, place, context, *args, **kwargs):
context = {
'google_analytics_id': self.get_config().get('google_analytics_id').get_value(),
'web_master_tools_id': self.get_config().get('web_master_tools_id').get_value(),
}
return self.render_block(
request,
template_name='googleanalytics/googleanalytics_block.html',
block_title=_('Google Analytics'),
context=context,
)
class PluginConfig(Plugin):
name = 'Registration'
description = 'Registration plugin'
version = '0.0.1'
url_prefixes = (({
'en': 'registration',
'es': 'registro'
}, 'plugins.registration.urls'), )
config_params = [
params.PositiveInteger(
name='caducity',
label=_('hours before the registration url expires (0 for never)'),
default=72),
params.Single(
name='profile_form_class',
label=_('Form class to save extra profile data'),
default="plugins.registration.forms.DefaultMerengueProfileForm"),
]
def get_actions(self):
return [RegisterAction]
def models(self):
return [(Registration, RegistrationAdmin)]
class UserTimelineBlock(TimelineProvider, Block):
name = 'usertimeline'
default_place = 'rightsidebar'
verbose_name = _('Timeline of Twitter User')
help_text = _('Block to show a timeline of Twitter for an user.')
template_name = 'twitter/timeline_block.html'
config_params = BaseBlock.config_params + [params.PositiveInteger(name='limit',
label=ugettext('Limit for twitter block'),
default=3),
params.Single(name='user',
label=ugettext('Tweets of this user'),
default='merengueproject'),
]
def get_block_title(self):
user = self.get_config().get('user', []).get_value()
return "@%s" % user
def get_link(self):
error = self.get_tweets()
if "doesn't exists" in error[1]:
return ('Twitter Mainpage', 'http://www.twitter.com/')
else:
user = self.get_config().get('user', []).get_value()
return ('Follow ' + user + ' on Twitter!', 'http://www.twitter.com/#!/' + user + '/')
class PluginConfig(Plugin):
name = 'ITags'
description = 'Internazionalized Tags'
version = '0.0.1a'
config_params = [
params.Single(name='main_language', label=_('Main language for tags'), default=settings.LANGUAGE_CODE),
]
url_prefixes = (
('itags', 'plugins.itags.urls'),
)
def get_model_admins(self):
return [(ITag, ITagAdmin)]
def get_viewlets(self):
return [TagCloudViewlet]
def get_blocks(self):
return [TagCloudBlock, ContentTagsBlock]
def post_install(self):
from tagging.models import Tag
[i.save() for i in Tag.objects.all()]
class HashtagTimelineBlock(TimelineProvider, Block):
name = 'hashtagtimeline'
default_place = 'rightsidebar'
verbose_name = _('Timeline of Tag in Twitter ')
help_text = _('Block to show a timeline of Twitter for a hashtag.')
template_name = 'twitter/hashtag_timeline_block.html'
config_params = BaseBlock.config_params + [params.PositiveInteger(name='limit',
label=ugettext('Limit for twitter block'),
default=3),
params.Single(name='hashtag',
label=ugettext('Tweets of a hashtag'),
default='#merengueproject'),
]
def get_block_title(self):
hashtag = self.get_config().get('hashtag', []).get_value()
return hashtag
def get_link(self):
hashtag = self.get_config().get('hashtag', []).get_value()
if hashtag.startswith('#'):
return ('Search ' + hashtag + ' on Twitter!', 'http://www.twitter.com/#!/search/%23' + hashtag[1:] + '/')
else:
return ('Search ' + hashtag + ' on Twitter!', 'http://www.twitter.com/#!/search/' + hashtag + '/')
class PluginConfig(Plugin):
"""
Redirect Plugin config instance
"""
name = 'Redirects'
description = 'Redirects Plugin'
version = '0.0.1'
config_params = [
params.Single(name='review_title',
label=_('title for reviewing task'),
default=_('Review this redirection')),
params.List(name="review_users",
label=_("Users by default to have redirects reviewed"),
choices=get_user_choices),
params.List(name="review_groups",
label=_("User groups by default to have redirects reviewed"),
choices=get_group_choices),
]
def get_middlewares(self):
return ['plugins.redirects.middleware.RedirectMiddleware']
def get_model_admins(self):
return [(Redirect, RedirectAdmin), ]
def get_perms(self):
return (
(_('Submit redirects'), 'submit_redirects', [Redirect], ),
(_('Manage redirects'), 'manage_redirects', [Redirect], )
)
class PluginConfig(ContentTypeFilterProvider, Plugin):
name = 'RSS syndication'
description = 'Plugin to allow RSS syndication of contents'
version = '0.0.1a'
url_prefixes = (('rss', 'plugins.rss.urls'), )
config_params = ContentTypeFilterProvider.config_params + [
params.PositiveInteger(
name="limit",
label=_("number of elements to show at the feed"),
default=10,
),
params.Single(name="portal",
label=_("portal name that will be shown as RSS title"),
default="Merengue RSS"),
]
def get_actions(self):
return [GenerateRSS, GenerateSectionRSS]
def get_model_admins(self):
return []
def get_blocks(self):
return [
RSSGlobalFeed,
]
class GoogleSearchBlock(Block):
name = 'googlesearch'
default_place = 'leftsidebar'
verbose_name = ugettext_lazy('Google Search Block')
help_text = ugettext_lazy('The block represents the google search widget')
default_caching_params = {
'enabled': False,
'only_anonymous': False,
'vary_on_user': False,
'timeout': 5184000,
'vary_on_url': False,
'vary_on_language': True,
}
config_params = BaseBlock.config_params + [
params.Single(name='custom_search_control',
label=_('Custom search control'),
default='003808332573069177904:wm3_yobt584'),
params.Single(name='search_result_content',
label=_('Search result content (element\'s id of DOM)'),
default='content'),
params.Single(name='search_form_content',
label=_('Search form content (element\'s id of DOM)'),
default='cse'),
]
def render(self,
request,
place,
context,
block_content_relation=None,
*args,
**kwargs):
language_get = request.GET.get('set_language', None)
# if we just change the language, get_language_from_request function does
# not work fine, so first we check if the language have changed now
language = language_get or get_language_from_request(request)
return self.render_block(
request,
template_name='googlesearch/block_googlesearch.html',
block_title=_('Search'),
context={
'plugin_config': self.get_config(),
'language': language
})
class PluginConfig(Plugin):
name = 'EzDashboard'
description = 'Dashboard for users plugins like iGoogle, based on ' \
'EzWeb platform'
version = '0.0.2a'
url_prefixes = (({
'en': 'dashboard',
'es': 'escritorio'
}, 'plugins.ezdashboard.urls'), )
required_apps = ('django.contrib.sites', )
config_params = [
params.Single(name='url',
label=_('EzWeb base URL'),
default='http://ezweb.yaco.es/'),
params.Single(name='style',
label=_('EzWeb iframe CSS style'),
default='border: none;'),
params.Single(name='class',
label=_('EzWeb iframe CSS class'),
default=''),
params.Single(name='width',
label=_('EzWeb iframe width'),
default='100%'),
params.Single(name='height',
label=_('EzWeb iframe height'),
default='500px'),
params.Single(name='lite', label=_('EzWeb lite'), default=True),
]
def get_actions(self):
return [
DashboardAction,
]
class PluginConfig(Plugin):
name = 'Piwik'
description = 'Piwik integration plugin'
version = '0.0.1'
url_prefixes = (({
'en': 'stats',
'es': 'estadisticas'
}, 'plugins.piwik.urls'), )
config_params = [
params.Single(name='token', label=_('authentication token')),
params.Single(name='url', label=_('piwik url')),
params.Single(name='site_id', label=_('site id')),
params.Single(name='metric', label=_('metric'), default=METRIC),
params.Single(name='period', label=_('period'), default=PERIOD),
params.Single(name='date', label=_('date'), default=DATE),
]
def get_actions(self):
return []
def get_blocks(self):
return [PiwikBlock]
def section_models(self):
return []
def get_perms(self):
return [('View all stats', 'view_all_stats'),
('View my stats', 'view_my_stats')]
class PluginConfig(Plugin):
name = 'Core'
description = 'Core plugin'
version = '0.0.1a'
model_admins = [
(CustomMeta, CustomMetaAdmin),
(Document, DocumentAdmin),
(Photo, PhotoAdmin),
(Video, VideoAdmin),
(Audio, AudioAdmin),
]
url_prefixes = (
('core', 'plugins.core.urls'),
)
config_params = [
params.Content(name='home_initial_content',
label=_('home initial content'), default=1),
params.Single(name='login_url',
label=_('Login URL'), default=settings.LOGIN_URL)]
def get_actions(self):
return [AdminAction, LoginAction, LogoutAction, PrintAction, HotLinkAction]
def get_blocks(self):
return [CoreMenuBlock, NavigationBlock, PortalMenuBlock,
ContactInfoBlock, AnnouncementsBlock, PortalLinksBlock]
def get_toolbar_panels(self):
return [InplaceEditPanel, InlineTransPanel, AddBlockPanel,
InvalidateCachePanel, VersionPanel, ]
def models(self):
return self.model_admins
def get_model_admins(self):
return self.model_admins
def section_models(self):
return [(Document, DocumentRelatedModelAdmin)]
def get_perms(self):
return ()
def get_section_prefixes(self):
return (reverse('section_index'), )
class PluginConfig(Plugin):
name = 'Custom portlet'
description = 'Custom portlet'
version = '0.0.1a'
config_params = [
params.Single(name='limit',
label=_('data limit of custom portlet'),
default=customportlet.MAX_BLOCKS_NUMBER),
]
@classmethod
def get_blocks(cls):
return [CustomPortletBlock]
@classmethod
def get_model_admins(cls):
return [(CustomPortlet, CustomPortletAdmin)]
class CategorizedBannerBlock(BannerBlock):
config_params = BannerBlock.config_params + [
params.Single(name='category',
label=ugettext('slug of the category to filter'),
default=''),
]
def get_contents(self, request=None, context=None, section=None):
banners_list = Banner.objects.published()
if section and self.get_config().get('filtering_section',
False).get_value():
banners_list = filtering_in_section(banners_list, section)
category_name = self.get_config().get('category',
'').get_value() or None
if category_name:
banners_list = banners_list.filter(categories__slug=category_name)
return banners_list
class AllBannerViewlet(ViewLetQuerySetItemProvider, Viewlet):
name = 'allbanner'
help_text = _('All Banners')
verbose_name = _('All banner block')
config_params = ViewLetQuerySetItemProvider.config_params + [
params.Single(name='limit', label=ugettext('limit for banner viewlet'),
default='3'),
]
def get_contents(self, request=None, context=None, section=None):
number_banners = self.get_config().get('limit', []).get_value()
banners_list = get_banners(request, number_banners)
return banners_list
def render(self, request, context):
banner_list = self.get_queryset(request, context)
return self.render_viewlet(request, template_name='banner/viewlet_latest.html',
context={'banner_list': banner_list,
'is_paginated': True,
'paginate_by': 10})
class LatestLinkViewlet(ViewLetQuerySetItemProvider, Viewlet):
name = 'latestlink'
help_text = _('Latest link')
verbose_name = _('Latest links')
config_params = ViewLetQuerySetItemProvider.config_params + [
params.Single(name='limit',
label=ugettext('limit for link viewlet'),
default='10'),
]
def get_contents(self, request=None, context=None, section=None):
number_links = self.get_config().get('limit', []).get_value()
link_list = get_links(request, number_links)
return link_list
def render(self, request, context):
link_list = self.get_queryset(request, context)
return self.render_viewlet(request,
template_name='link/viewlet_latest.html',
context={'link_list': link_list})
class PortalLinksBlock(LinkBaseBlock):
"""Generic block that renders portal links"""
name = 'portallinks'
default_place = 'header'
help_text = _('Generic block that renders portal links')
verbose_name = _('Portal Links Block')
config_params = BaseBlock.config_params + [
params.Single(
name="category",
label=_("Portal link category"),
choices=settings.PORTAL_LINK_CATEGORIES,
default=settings.PORTAL_LINK_CATEGORIES[0][0],
),
]
@property
def category(self):
return self.get_config().get('category', None).get_value()
@property
def template_name(self):
category = self.get_config().get('category', None).get_value()
return 'core/block_%slinks.html' % category
class BaseBlock(RegistrableItem):
model = RegisteredBlock
singleton = False
is_addable = True
cache_allowed = True
default_caching_params = {
'enabled': False,
'only_anonymous': False,
'timeout': 0,
'vary_on_url': False,
'vary_on_language': True,
'vary_on_user': False,
}
config_params = [
params.Single(name='css_class',
label=_('css class to add to this block'),
default=''),
]
def __init__(self, reg_item):
super(BaseBlock, self).__init__(reg_item)
self.content = getattr(reg_item, 'content', None)
@classmethod
def get_category(cls):
return 'block'
def get_rendered_content(self, request, render_args):
""" render the block content, using cached content is needed """
if settings.DEBUG:
start = time()
rendered_content = self.get_cached_content(request)
if rendered_content is None:
is_cached = False
rendered_content = self.render(*render_args)
self.set_cached_content(rendered_content, request)
else:
is_cached = True
if settings.DEBUG:
block_debug_info
stop = time()
duration = stop - start
block_id = '%s.%s:%d' % (self.get_module(), self.get_class_name(),
self.reg_item.id)
block_debug_info[block_id] = {
'block': block_id,
'module': self.get_module(),
'class_name': self.get_class_name(),
'is_cached': is_cached,
'time': duration,
}
logger.debug('(%.3f) %s; cached=%s' %
(duration, block_id, is_cached),
extra={
'duration': duration,
'block': block_id,
'is_cached': is_cached
})
return rendered_content
@classmethod
def get_models_refresh_cache(self):
return []
def render_block(self,
request,
template_name='block.html',
block_title=None,
context=None):
if context is None:
context = {}
registered_block = self.get_registered_item()
css_class = self.get_config().get('css_class', None)
css_class = css_class and css_class.get_value() or ''
block_context = {
'block_name': registered_block.name,
'placed_at': registered_block.placed_at,
'fixed_place': getattr(registered_block, 'fixed_place', False),
'block_title': block_title or registered_block.name,
'registered_block': registered_block,
'css_class': css_class,
'has_config': self.has_config(),
}
block_context.update(context)
rendered_content = render_to_string(
template_name,
block_context,
context_instance=RequestContext(request))
return rendered_content
def _get_cache_key(self, request):
registered_block = self.reg_item
key_prefix = 'blocks_cache_%d' % registered_block.id
if registered_block.cache_vary_on_url:
key_prefix += '-%s' % urlquote(request.META['PATH_INFO'])
params = request.GET.urlencode()
if params:
key_prefix += '?%s' % params
if registered_block.cache_vary_on_language:
key_prefix += '-%s' % get_language()
if registered_block.cache_vary_on_user:
key_prefix += '-%s' % request.user.username
if len(key_prefix) > settings.CACHE_MAX_KEY:
key_prefix = hashlib.md5(key_prefix).hexdigest()
return key_prefix
def _get_registry_cache_key(self):
return 'blocks_cache_registry'
def is_cacheable(self, request):
registered_block = self.reg_item
return registered_block.is_cached and \
not (not request.user.is_anonymous() and registered_block.cache_only_anonymous)
def get_cached_content(self, request):
if not self.is_cacheable(request):
return None
cache_key = self._get_cache_key(request)
return cache.get(cache_key)
def set_cached_content(self, content, request):
if not self.is_cacheable(request):
return # not need to cache nothing
cache_key = self._get_cache_key(request)
self._register_cache_key(cache_key)
content = '<div class="cached-block">%s</div>' % content
return cache.set(cache_key, content, self.reg_item.cache_timeout)
def set_default_caching(self):
reg_block = self.reg_item
def_caching_params = self.default_caching_params
reg_block.is_cached = def_caching_params.get('enabled', False)
reg_block.cache_timeout = def_caching_params.get('timeout', 0)
reg_block.cache_only_anonymous = def_caching_params.get(
'only_anonymous', False)
reg_block.cache_vary_on_language = def_caching_params.get(
'vary_on_language', True)
reg_block.cache_vary_on_url = def_caching_params.get(
'vary_on_url', False)
reg_block.cache_vary_on_user = def_caching_params.get(
'vary_on_user', False)
reg_block.save
def invalidate_cache(self):
registry_cache_key = self._get_registry_cache_key()
cache_registry = self._get_registry_cache()
registered_block = self.reg_item
cache.delete_many(cache_registry[registered_block.id])
del cache_registry[registered_block.id]
cache.set(registry_cache_key, cache_registry)
def _get_registry_cache(self):
registry_cache_key = self._get_registry_cache_key()
registered_block = self.reg_item
cache_registry = cache.get(registry_cache_key)
if cache_registry is None:
cache_registry = {}
if registered_block.id not in cache_registry:
cache_registry[registered_block.id] = []
return cache_registry
def _register_cache_key(self, cache_key):
registry_cache_key = self._get_registry_cache_key()
cache_registry = self._get_registry_cache()
cache_registry[self.reg_item.id].append(cache_key)
cache.set(registry_cache_key, cache_registry)
class PluginConfig(Plugin):
name = 'Saml2'
description = 'Adds SAML2 authentication and authorization to Merengue'
version = '0.1.0dev'
url_prefixes = (('saml2', 'plugins.saml2.urls'), )
required_plugins = {'core': {}}
required_apps = {
'djangosaml2': {},
}
config_params = [
params.Single(name='entity_name', label=_('Entity Name')),
params.Single(name='username_attribute',
label=_('Username attribute'),
default='uid'),
params.Single(name='first_name_attribute',
label=_('First name attribute'),
default='cn'),
params.Single(name='last_name_attribute',
label=_('First name attribute'),
default='sn'),
params.Single(name='email_attribute',
label=_('Email attribute'),
default='mail'),
params.Single(
name='required_attributes',
label=_('Comma/space separated list of required attributes'),
default='uid'),
params.Single(
name='optional_attributes',
label=_('Comma/space separated list of optional attributes'),
default=''),
params.Single(name='xmlsec_binary',
label=_('Path to xmlsec1 program'),
default='/usr/bin/xmlsec1'),
params.Single(name='key_file_path',
label=_('Certificate private part')),
params.Single(name='cert_file_path',
label=_('Certificate public part')),
params.PositiveInteger(name='valid_for',
label=_('Expiration time in hours'),
default=24)
]
def get_model_admins(self):
return [
(IdentityProvider, IdentityProviderAdmin),
(ContactPerson, ContactPersonAdmin),
(Organization, OrganizationAdmin),
]
def get_actions(self):
return [Saml2LoginAction, Saml2LogoutAction]
def post_actions(self):
login_smal2_url = '/saml2/login/'
plugin = RegisteredPlugin.objects.get_by_item(get_plugin('core'))
login_url = plugin.config.get('login_url', None)
if login_url != login_smal2_url and (not login_url or login_url
== settings.LOGIN_URL):
plugin.config['login_url'] = login_smal2_url
plugin.save()
class LatestFilesBlock(BlockQuerySetItemProvider, Block):
name = 'latestfiles'
default_place = 'rightsidebar'
verbose_name = _('Latest Files Block')
help_text = _(
'Block that represents a list of recent files of the filebrowser')
config_params = BaseBlock.config_params + BlockQuerySetItemProvider.config_params + [
params.PositiveInteger(
name='limit',
label=_('number of files for the "Latest Files" block'),
default=3,
),
params.Single(
name='mainrepo',
label=_('Name of the repository to show files from it'),
default='',
),
params.Bool(
name='filtering_document',
label=
_('If the repository name is equal to document slug, filter for the files of this repository'
),
default=False,
),
]
default_caching_params = {
'enabled': False,
'timeout': 3600,
'only_anonymous': True,
'vary_on_user': False,
'vary_on_url': True,
'vary_on_language': True,
}
def get_contents(self, request=None, context=None, section=None):
repos = Repository.objects.all()
return repos
def queryset(self, request=None, context=None, section=None):
queryset = self.get_contents(request, context, section)
content = context.get('content', None)
document = isinstance(content, Document) and content
if section and self.get_config().get('filtering_section',
False).get_value():
queryset = queryset.filter(section=section)
if self.get_config().get('filtering_document', False).get_value() and \
document and queryset.filter(name=document.slug):
queryset = queryset.filter(name=document.slug)
return queryset
def render(self, request, place, context, *args, **kwargs):
repolist = self.get_queryset(request, context)
limit = self.get_config().get('limit').get_value()
mainrepo = self.get_config().get('mainrepo').get_value()
main = None
if mainrepo:
try:
main = repolist.get(name=mainrepo)
except Repository.DoesNotExist:
pass
if main:
files = main.latest_files(limit)
else:
if not repolist:
return ''
files = []
for repo in repolist:
files += repo.latest_files(limit)
if not files:
return ''
files = sorted(files, key=lambda f: f.modificated,
reverse=True)[:limit]
return self.render_block(
request,
template_name='filebrowser/blocks/latestfiles.html',
block_title=ugettext('Downloads'),
context={
'files': files,
})
class HighlightMenu(Block):
name = 'highlightmenu'
verbose_name = _('Highlight menu')
help_text = _('Block with the microsite links')
default_place = 'rightsidebar'
config_params = Block.config_params + BlockQuerySetItemProvider.config_params + [
params.PositiveInteger(
name='limit',
label=_('number of links for the "Highlight menu" block'),
default=5,
),
params.Single(
name='background',
label=_('background color for the "Highlight menu" block'),
default='#ffffff',
),
params.Single(
name='link_color',
label=_('color of the links inside the "Highlight menu" block'),
default='#0000ff',
),
params.Single(
name='over_color',
label=
_('color of the links (when the mouse is over) inside the "Highlight menu" block'
),
default='#ff00ff',
),
]
default_caching_params = {
'enabled': False,
'timeout': 3600,
'only_anonymous': True,
'vary_on_user': False,
'vary_on_url': True,
'vary_on_language': True,
}
@classmethod
def get_models_refresh_cache(self):
return [MicroSiteLink]
def render(self, request, place, context, *args, **kwargs):
section = get_section(request, context)
if isinstance(section, MicroSite):
microsite = section
limit = self.get_config().get('limit').get_value()
links = MicroSiteLink.objects.filter(
microsite=microsite).visible_by_user(request.user)
links = links[:limit]
conf = {
'background': self.get_config().get('background').get_value(),
'link_color': self.get_config().get('link_color').get_value(),
'over_color': self.get_config().get('over_color').get_value(),
}
else:
microsite = None
links = []
conf = {}
return self.render_block(
request,
template_name='microsite/blocks/highlight_menu.html',
block_title=ugettext('Highlight menu'),
context={
'microsite': microsite,
'links': links,
'conf': conf
})
