コード例 #1
0
ファイル: plugin.py プロジェクト: okfn/ckanext-ecportal
    def before_search(self, search_params):
        search_string = search_params.get("q") or ""

        # for search cloud we don't make any changes to the search_params,
        # just log the search string to the database for later analysis.

        # do some clean up of the search string so that the analysis
        # will be easier later
        search_string = searchcloud.unify_terms(search_string, max_length=200)
        if not search_string:
            return search_params
        lang = str(helpers.current_locale())
        try:
            # Unfortunately a nested session doesn't behave the way we want,
            # failing to actually commit the change made.
            # We can either create a separate connection for this
            # functionality on each request (potentially costly),
            # or just commit at this point on the basis that for a search
            # request, no changes that can't be committed will have been
            # saved to the database. For now, we choose the latter.
            ## model.Session.begin_nested() # establish a savepoint
            searchcloud.track_term(model.Session, lang, search_string)
        except sqlalchemy.exc.ProgrammingError, e:
            # We don't want the non-existence of the search_query table to
            # crash searches, we just won't log queries
            log.error(e)
            if 'relation "search_query" does not exist' in str(e):
                log.error(
                    "Please run the paster searchcloud-install-tables "
                    "command to set up the correct tables for "
                    "search logging"
                )
                model.Session.rollback()
            else:
                raise
コード例 #2
0
ファイル: forms.py プロジェクト: euopendataportal/source
    def setup_template_variables(self, context, data_dict=None, package_type=None):
        c = tk.c
        ckan_lang = str(helpers.current_locale())
        ckan_lang_fallback = str(helpers.fallback_locale())

        c.is_sysadmin = new_authz.is_sysadmin(c.user)

        factory = ControlledVocabularyFactory()

        #self.license = factory.get_controlled_vocabulary_util(ControlledVocabularyFactory.LICENSE) #type: ControlledVocabularyUtil

        # Initialize cache if needed
        self.license = controlled_vocabulary_util.retrieve_all_licenses(ckan_lang)

            # Initialize cache if needed
        self.geographical_coverage = controlled_vocabulary_util.retrieve_all_geographical_coverage(ckan_lang)

        self.controlled_keyword = controlled_vocabulary_util.retrieve_all_controlled_keyword(ckan_lang)

        self.domains_eurovoc = controlled_vocabulary_util.retrieve_all_themes(ckan_lang)

        self.status = controlled_vocabulary_util.retrieve_all_datasets_status(ckan_lang)

        self.type_of_dataset = controlled_vocabulary_util.retrieve_all_datasets_types(ckan_lang)

        self.languages = controlled_vocabulary_util.retrieve_all_languages(ckan_lang)

        self.frequency = controlled_vocabulary_util.retrieve_all_frequencies(ckan_lang)

        self.temporal_granularity = controlled_vocabulary_util.retrieve_all_time_periodicity(ckan_lang)

        #self.notation_skos = controlled_vocabulary_util.retrieve_all_notation_skos(ckan_lang)
        self.notation_skos = controlled_vocabulary_util.retrieve_all_notation_types(ckan_lang)

        self.formats = factory.get_controlled_vocabulary_util(ControlledVocabularyFactory.FILE_TYPE) #type: ControlledVocabularyUtil

        if (c.action in (u'edit', u'new', u'editresources', u'manage_package', u'update', 'bulk_update')):

            c.license = self.license
            c.geographical_coverage = self.geographical_coverage
            c.controlled_keyword = self.controlled_keyword
            c.domains_eurovoc = self.domains_eurovoc
            c.publishers = helpers.organizations_available(c.user)
            c.status = controlled_vocabulary_util.retrieve_all_datasets_status(ckan_lang)
            c.type_of_dataset = controlled_vocabulary_util.retrieve_all_datasets_types(ckan_lang)
            c.languages = controlled_vocabulary_util.retrieve_all_languages(ckan_lang)
            c.temporal_granularity = controlled_vocabulary_util.retrieve_all_time_periodicity(ckan_lang)
            c.groups = homepage.get_groups('display_name')
            c.frequency = self.frequency
            c.notation_skos = self.notation_skos
            c.formats = self.formats.get_all_values_for_form(ckan_lang)


            # datasets_titles_dict = self.retrieve_all_datasets_titles(c)
            # c.datasets = datasets_titles_dict

        if c.action in (u'dashboard'):
            c.formats = FORMATS

        # get new group name if group ID in query string
        new_group_id = pylons.request.params.get('groups__0__id')
        if new_group_id:
            try:
                data = {'id': new_group_id}
                new_group = p.toolkit.get_action('group_show')(context, data)
                c.new_group = new_group['name']
            except p.toolkit.ObjectNotFound:
                c.new_group = None

        # find extras that are not part of our schema
        c.additional_extras = []
        schema_keys = self.create_package_schema().keys()
        if c.pkg_dict:
            extras = c.pkg_dict.get('extras', [])
            if extras:
                for extra in extras:
                    if not extra['key'] in schema_keys:
                        c.additional_extras.append(extra)

        # This is messy as auths take domain object not data_dict
        context_pkg = context.get('package', None)
        pkg = context_pkg or c.pkg
        if pkg:
            try:
                if not context_pkg:
                    context['package'] = pkg
                logic.check_access('package_update', context)
                c.auth_for_change_state = True
            except logic.NotAuthorized:
                c.auth_for_change_state = False
コード例 #3
0
    def index(self):
        context = {'for_view': True}

        start = time.time()
        locale = ckanext_helpers.current_locale().language
        c.package_count = ckanext_helpers.get_package_count()
        c.approved_search_terms = ckanext_helpers.approved_search_terms()
        c.most_viewed_datasets = ckanext_helpers.most_viewed_datasets()
        c.recent_updates = ckanext_helpers.recent_updates(10)

        publishers = get_action('get_skos_hierarchy')(context, None)
        factory = ControlledVocabularyFactory()
        publ_mdr = factory.get_controlled_vocabulary_util(ControlledVocabularyFactory.CORPORATE_BODY) #type: CorporateBodiesUtil
        for top_level, item in publishers.items():
            translation = publ_mdr.get_translation_for_language(top_level, locale)
            item['name'] = top_level.split('/')[-1].lower()
            item['label'] = translation
            interim = []
            for child in item.get('children', []):
                translation = publ_mdr.get_translation_for_language(child[0], locale)
                interim.append((child[0].split('/')[-1].lower(), translation, child[1]))
            item['children'] = sorted(interim, key=lambda child: child[1])
        c.get_skos_hierarchy = publishers
        c.most_common_themes = get_action('theme_list')(context, {'mode': 'most_common'})
        c.less_common_themes = get_action('theme_list')(context, {'mode': 'less_common'})
        #c.get_eurovoc_domains_by_packages_with_cache_most =homepage.get_eurovoc_domains_by_packages_with_cache('most_common', locale)
        #c.get_eurovoc_domains_by_packages_with_cache_less= homepage.get_eurovoc_domains_by_packages_with_cache('less_common', locale)

        duration = time.time()-start
        log.info("Build all cache took {0}".format(duration))
        if c.userobj is not None:
            msg = None
            url = h.url_for(controller='user', action='edit')
            is_google_id = \
                c.userobj.name.startswith(
                    'https://www.google.com/accounts/o8/id')
            if not c.userobj.email and (is_google_id and
                                        not c.userobj.fullname):
                msg = _(u'Please <a href="{link}">update your profile</a>'
                        u' and add your email address and your full name. '
                        u'{site} uses your email address'
                        u' if you need to reset your password.'.format(
                            link=url, site=g.site_title))
            elif not c.userobj.email:
                msg = _('Please <a href="%s">update your profile</a>'
                        ' and add your email address. ') % url + \
                    _('%s uses your email address'
                        ' if you need to reset your password.') \
                    % g.site_title
            elif is_google_id and not c.userobj.fullname:
                msg = _('Please <a href="%s">update your profile</a>'
                        ' and add your full name.') % (url)
            if msg:
                h.flash_notice(msg, allow_html=True)
        log.info("Use Home extension")
        start = time.time()
        response_str = base.render('home/index.html', cache_force=True)
        duration = time.time() - start
        log.info("Build Render index  took {0}".format(duration))
        # request.environ['CKAN_PAGE_CACHABLE'] = True
        # response.headers["Cache-Control"] = "max-age=604800"
        return response_str
        # return base.render('home/static.html', cache_force=True)
コード例 #4
0
ファイル: forms.py プロジェクト: neoflex/ckanext-ecportal
    def setup_template_variables(self, context, data_dict=None,
                                 package_type=None):
        c = p.toolkit.c

        ckan_lang = str(helpers.current_locale())
        ckan_lang_fallback = str(helpers.fallback_locale())

        c.licences = sorted(model.Package.get_license_options(),
                            key=operator.itemgetter(1))
        default_licence = (
            "Europa Legal Notice",
            "http://open-data.europa.eu/kos/licence/EuropeanCommission")
        c.licences = filter(lambda l: l != default_licence, c.licences)
        c.licences.insert(0, default_licence)

        c.is_sysadmin = Authorizer().is_sysadmin(c.user)

        c.status = _tags_and_translations(
            context, STATUS_VOCAB_NAME, ckan_lang, ckan_lang_fallback)
        c.interoperability_levels = _tags_and_translations(
            context, INTEROP_VOCAB_NAME, ckan_lang, ckan_lang_fallback)
        c.type_of_dataset = _tags_and_translations(
            context, DATASET_TYPE_VOCAB_NAME, ckan_lang, ckan_lang_fallback)
        c.geographical_coverage = _tags_and_translations(
            context, GEO_VOCAB_NAME, ckan_lang, ckan_lang_fallback)
        c.languages = _tags_and_translations(
            context, LANGUAGE_VOCAB_NAME, ckan_lang, ckan_lang_fallback)
        c.temporal_granularity = [(u'', u'')] + _tags_and_translations(
            context, TEMPORAL_VOCAB_NAME, ckan_lang, ckan_lang_fallback)

        # publisher IDs and name translations
        c.publishers = helpers.groups_available(c.user)

        # get new group name if group ID in query string
        new_group_id = pylons.request.params.get('groups__0__id')
        if new_group_id:
            try:
                data = {'id': new_group_id}
                new_group = p.toolkit.get_action('group_show')(context, data)
                c.new_group = new_group['name']
            except p.toolkit.ObjectNotFound:
                c.new_group = None

        # find extras that are not part of our schema
        c.additional_extras = []
        schema_keys = self.form_to_db_schema().keys()
        if c.pkg_dict:
            extras = c.pkg_dict.get('extras', [])
            for extra in extras:
                if not extra['key'] in schema_keys:
                    c.additional_extras.append(extra)

        # This is messy as auths take domain object not data_dict
        context_pkg = context.get('package', None)
        pkg = context_pkg or c.pkg
        if pkg:
            try:
                if not context_pkg:
                    context['package'] = pkg
                logic.check_access('package_change_state', context)
                c.auth_for_change_state = True
            except logic.NotAuthorized:
                c.auth_for_change_state = False