def update_config(self, config): u''' Set up the resource library, public directory and template directory for the view ''' # https://datatables.net/reference/option/lengthMenu self.page_length_choices = toolkit.aslist( config.get(u'ckan.datatables.page_length_choices', DEFAULT_PAGE_LENGTH_CHOICES)) self.page_length_choices = [int(i) for i in self.page_length_choices] self.state_saving = toolkit.asbool( config.get(u'ckan.datatables.state_saving', True)) # https://datatables.net/reference/option/stateDuration self.state_duration = toolkit.asint( config.get(u'ckan.datatables.state_duration', DEFAULT_STATE_DURATION)) self.data_dictionary_labels = toolkit.asbool( config.get(u'ckan.datatables.data_dictionary_labels', True)) self.ellipsis_length = toolkit.asint( config.get(u'ckan.datatables.ellipsis_length', DEFAULT_ELLIPSIS_LENGTH)) self.date_format = config.get(u'ckan.datatables.date_format', DEFAULT_DATE_FORMAT) self.default_view = config.get(u'ckan.datatables.default_view', 'table') toolkit.add_template_directory(config, u'templates') toolkit.add_public_directory(config, u'public') toolkit.add_resource(u'public', u'ckanext-datatablesview')
def update_config(self, config): u''' Load config and set up the resource library, public directory and template directory for the view ''' # https://datatables.net/reference/option/lengthMenu self.page_length_choices = toolkit.aslist( config.get(u'ckan.datatables.page_length_choices', DEFAULT_PAGE_LENGTH_CHOICES)) self.page_length_choices = [int(i) for i in self.page_length_choices] self.top_pagination_controls = toolkit.asbool( config.get(u'ckan.datatables.top_pagination_controls', False)) self.search_delay = toolkit.asint( config.get(u'ckan.datatables.search_delay', DEFAULT_SEARCH_DELAY)) self.state_saving = toolkit.asbool( config.get(u'ckan.datatables.state_saving', True)) # https://datatables.net/reference/option/stateDuration self.state_duration = toolkit.asint( config.get(u'ckan.datatables.state_duration', DEFAULT_STATE_DURATION)) self.data_dictionary_labels = toolkit.asbool( config.get(u'ckan.datatables.data_dictionary_labels', True)) toolkit.add_template_directory(config, u'templates') toolkit.add_public_directory(config, u'public') toolkit.add_resource(u'public', u'ckanext-datatablesview')
def run(ctx, host, port, disable_reloader, threaded, extra_files, processes): u"""Runs the Werkzeug development server""" use_reloader = not disable_reloader threaded = threaded or tk.asbool(config.get(u"ckan.devserver.threaded")) processes = processes or tk.asint( config.get(u"ckan.devserver.multiprocess", 1) ) if threaded and processes > 1: tk.error_shout(u"Cannot have a multithreaded and multi process server") raise click.Abort() log.info(u"Running server {0} on port {1}".format(host, port)) config_extra_files = tk.aslist( config.get(u"ckan.devserver.watch_patterns") ) extra_files = list(extra_files) + [ config[u"__file__"] ] + config_extra_files run_simple( host, port, ctx.obj.app, use_reloader=use_reloader, use_evalex=True, threaded=threaded, processes=processes, extra_files=extra_files, )
def _request(self, entity_type: str, entity_name: str) -> Dict: url = self.url + f"/jsonapi/{entity_type}/{entity_name}" timeout = tk.asint( tk.config.get(CONFIG_REQUEST_TIMEOUT, DEFAULT_REQUEST_TIMEOUT)) req = requests.get(url, timeout=timeout) req.raise_for_status() return req.json()
def authorize(authorizer, context, data_dict): """Request an authorization token for a list of scopes """ scopes = toolkit.get_or_bust(data_dict, 'scopes') if isinstance(scopes, string_types): scopes = scopes.split(' ') requested_scopes = [Scope.from_string(s) for s in scopes] max_lifetime = util.get_config_int('jwt_max_lifetime', DEFAULT_MAX_LIFETIME) lifetime = min(toolkit.asint(data_dict.get('lifetime', max_lifetime)), max_lifetime) expires = datetime.now(tz=pytz.utc) + timedelta(seconds=lifetime) try: granted_scopes = [ str(scope) for scope in filter(None, ( authorizer.authorize_scope(s, context=context) for s in requested_scopes)) ] except UnknownEntityType as e: raise toolkit.ValidationError(str(e)) user = context.get('auth_user_obj') return { "user_id": user.name if user else None, "token": _create_token(user, granted_scopes, expires), "expires_at": expires.isoformat(), "requested_scopes": [str(s) for s in requested_scopes], "granted_scopes": granted_scopes }
def run(ctx, host, port, disable_reloader, threaded, extra_files, processes, ssl_cert, ssl_key): u"""Runs the Werkzeug development server""" if tk.asbool(config.get("debug")): warnings.filterwarnings("default", category=CkanDeprecationWarning) # Reloading use_reloader = not disable_reloader config_extra_files = tk.aslist( config.get(u"ckan.devserver.watch_patterns") ) extra_files = list(extra_files) + [ config[u"__file__"] ] + config_extra_files # Threads and processes threaded = threaded or tk.asbool(config.get(u"ckan.devserver.threaded")) processes = processes or tk.asint( config.get(u"ckan.devserver.multiprocess", 1) ) if threaded and processes > 1: tk.error_shout(u"Cannot have a multithreaded and multi process server") raise click.Abort() # SSL cert_file = ssl_cert or config.get('ckan.devserver.ssl_cert') key_file = ssl_key or config.get('ckan.devserver.ssl_key') if cert_file and key_file: if cert_file == key_file == 'adhoc': ssl_context = 'adhoc' else: ssl_context = (ssl_cert, ssl_key) else: ssl_context = None host = host or config.get('ckan.devserver.host', DEFAULT_HOST) port = port or config.get('ckan.devserver.port', DEFAULT_PORT) try: port = int(port) except ValueError: tk.error_shout(u"Server port must be an integer, not {}".format(port)) raise click.Abort() log.info(u"Running CKAN on {scheme}://{host}:{port}".format( scheme='https' if ssl_context else 'http', host=host, port=port)) run_simple( host, port, ctx.obj.app, use_reloader=use_reloader, use_evalex=True, threaded=threaded, processes=processes, extra_files=extra_files, ssl_context=ssl_context, )
def _get_csv_reader(id: str): res = model.Resource.get(id) if res and utils.is_dotstat_url(res.url): with requests_cache.enabled( CACHE_PATH, expire_after=tk.asint( tk.config.get(CONFIG_DOTSTAT_CACHE_AGE, 60)), ): resp = requests.get(res.url, stream=True) if resp.ok: return csv.DictReader(resp.iter_lines(decode_unicode=True))
def clean_harvest_log(self): from datetime import datetime, timedelta from pylons import config from ckanext.harvest.model import clean_harvest_log # Log time frame - in days log_timeframe = toolkit.asint(config.get('ckan.harvest.log_timeframe', 30)) condition = datetime.utcnow() - timedelta(days=log_timeframe) # Delete logs older then the given date clean_harvest_log(condition=condition)
def clean_harvest_log(): from datetime import datetime, timedelta from ckantoolkit import config from ckanext.harvest.model import clean_harvest_log # Log time frame - in days log_timeframe = tk.asint(config.get("ckan.harvest.log_timeframe", 30)) condition = datetime.utcnow() - timedelta(days=log_timeframe) # Delete logs older then the given date clean_harvest_log(condition=condition)
def configure(self, config_): results.create_database_table() # Update the class variables for the config settings with the values # from the config file, *if* they're in the config file. config.recheck_resources_after = toolkit.asint( config_.get("ckanext.deadoralive.recheck_resources_after", config.recheck_resources_after)) config.resend_pending_resources_after = toolkit.asint( config_.get("ckanext.deadoralive.resend_pending_resources_after", config.resend_pending_resources_after)) config.broken_resource_min_fails = toolkit.asint( config_.get("ckanext.deadoralive.broken_resource_min_fails", config.broken_resource_min_fails)) config.broken_resource_min_hours = toolkit.asint( config_.get("ckanext.deadoralive.broken_resource_min_hours", config.broken_resource_min_hours)) config.authorized_users = toolkit.aslist( config_.get("ckanext.deadoralive.authorized_users", config.authorized_users))
def feedbackProv(self): current_user = t.get_action('user_show')({}, {'id': c.user}) request_sender_name = current_user['display_name'] try: receiver_user = t.get_action('user_show')({}, {'id': 'ecoembes'}) receiver_email = receiver_user['email'] except t.ObjectNotFound: receiver_email = config.get('ckan.feedback.receiver_email') sender_email = config.get('ckan.feedback.sender_email', '*****@*****.**') # build message logging.info('[DEBUG SMTP] START') msg = MIMEMultipart() msg['From'] = sender_email msg['To'] = receiver_email msg['Date'] = formatdate(localtime=True) msg['Subject'] = unicode('Nueva petición de datos recibida', 'utf-8').encode('utf-8') logging.info(msg) email_body = u'Nombre de usuario: ' + request_sender_name + unicode( "\nPetición: ", 'utf-8') + request.params['data_request_description'] logging.info('email_body:') logging.info(email_body) msg.attach(MIMEText(email_body.encode('utf-8'), _charset='utf-8')) logging.info('final message:') logging.info(msg) # send email try: smtp_address = config.get('ckan.feedback.smtp_address') smtp_port = t.asint(config.get('ckan.feedback.smtp_port', 25)) smtp_server = smtplib.SMTP(smtp_address, smtp_port) smtp_server.sendmail(sender_email, receiver_email, msg.as_string()) smtp_server.close() except socket.error: logging.error('Error establishing SMTP connection to server: ' + smtp_address + ' port ' + str(smtp_port)) raise logging.info('[DEBUG SMTP] END') return p.toolkit.render('feedbackProv.html')
def configure(self, config_): # Setup database tables db_setup() # Load and parse user attributes mapping user_mapping = t.aslist(config_.get('ckanext.cas.user_mapping')) for attr in user_mapping: key, val = attr.split('~') if '+' in val: val = val.split('+') self.USER_ATTR_MAP.update({key: val}) if not any(self.USER_ATTR_MAP): raise RuntimeError, 'User attribute mapping is required for plugin: {0}'.format(self.name) if 'email' not in self.USER_ATTR_MAP.keys(): raise RuntimeError, '"email" attribute mapping is required for plugin: {0}'.format(self.name) service_validation_url = config.get('ckanext.cas.service_validation_url', None) saml_validation_url = config.get('ckanext.cas.saml_validation_url', None) if (service_validation_url and saml_validation_url) or \ (not service_validation_url and not saml_validation_url): msg = 'Configure either "ckanext.cas.service_validation_url" or "ckanext.cas.saml_validation_url" but not both.' raise RuntimeError, msg if not config.get('ckanext.cas.login_url', None): raise RuntimeError, '"ckanext.cas.login_url" is required for plugin: {0}'.format(self.name) if not config.get('ckanext.cas.logout_url', None): raise RuntimeError, '"ckanext.cas.logout_url" is required for plugin: {0}'.format(self.name) if not config.get('ckanext.cas.application_url', None): raise RuntimeError, '"ckanext.cas.application_url" is required for plugin: {0}'.format(self.name) if service_validation_url: self.SERVICE_VALIDATION_URL = config.get('ckanext.cas.service_validation_url') self.CAS_VERSION = 2 elif saml_validation_url: self.SAML_VALIDATION_URL = config.get('ckanext.cas.saml_validation_url') self.CAS_VERSION = 3 self.CAS_LOGIN_URL = config.get('ckanext.cas.login_url') self.CAS_LOGOUT_URL = config.get('ckanext.cas.logout_url') self.CAS_APP_URL = config.get('ckanext.cas.application_url') self.CAS_COOKIE_NAME = config.get('ckanext.cas.cookie_name', 'sessionid') self.TICKET_KEY = config.get('ckanext.cas.ticket_key', 'ticket') self.SERVICE_KEY = config.get('ckanext.cas.service_key', 'service') self.REDIRECT_ON_UNSUCCESSFUL_LOGIN = config.get('ckanext.cas.unsuccessful_login_redirect_url', None) self.LOGIN_CHECKUP_TIME = t.asint(config.get('ckanext.cas.login_checkup_time', 600)) self.LOGIN_CHECKUP_COOKIE = config.get('ckanext.cas.login_checkup_cookie', 'cas_login_check') self.VERIFY_CERTIFICATE = t.asbool(config.get('ckanext.cas.verify_certificate', True))
def spc_download_tracking_list(context, data_dict): id = tk.get_or_bust(data_dict, 'id') pkg = model.Package.get(id) _check_access('spc_download_tracking_list', context, { 'id': id, 'owner_org': pkg.owner_org }) limit = tk.asint(data_dict.get('limit', 20)) offset = tk.asint(data_dict.get('offset', 0)) query = DownloadTracking.query(id=pkg.id) total = query.count() query = query.offset(offset).limit(limit) results = [{ 'package_id': resource.package_id, 'user': user.name, 'resource_id': resource.id, 'resource_name': resource.name, 'downloaded_at': track.downloaded_at.isoformat() } for (track, resource, user) in query] return {'results': results, 'count': total}
def _get_remote_resource_size(res): url = res.get('url') if not url: return 0 try: resp = requests.head(url, timeout=5, allow_redirects=True) except requests.exceptions.RequestException: logger.exception("Cannot fetch remote metadata for Resource<%s>", res['id']) return 0 try: return tk.asint(resp.headers['content-length']) except KeyError: return 0
def configure(self, config_): results.create_database_table() # Update the class variables for the config settings with the values # from the config file, *if* they're in the config file. config.recheck_resources_after = toolkit.asint(config_.get( "ckanext.deadoralive.recheck_resources_after", config.recheck_resources_after)) config.resend_pending_resources_after = toolkit.asint( config_.get( "ckanext.deadoralive.resend_pending_resources_after", config.resend_pending_resources_after)) config.broken_resource_min_fails = toolkit.asint( config_.get( "ckanext.deadoralive.broken_resource_min_fails", config.broken_resource_min_fails)) config.broken_resource_min_hours = toolkit.asint( config_.get( "ckanext.deadoralive.broken_resource_min_hours", config.broken_resource_min_hours)) config.authorized_users = toolkit.aslist( config_.get( "ckanext.deadoralive.authorized_users", config.authorized_users))
def event_description_length(): '''Allows renaming of "Group" To change this setting add to the [app:main] section of your CKAN config file:: ckan.mapactiontheme.group_name = MyGroupName Returns ``Group`` by default, if the setting is not in the config file. :rtype: boolean ''' value = config.get('ckan.mapactionevent.event_description_length', 200) value = toolkit.asint(value) return value
def wrapper(*args, **kwargs): conn = redis.connect_to_redis() key = pickle.dumps((args, kwargs)) value = conn.get(key) if value: return cast(T, json.loads(value)) value = func(*args, **kwargs) cache_duration = tk.asint( tk.config.get(CONFIG_CACHE_DURATION, DEFAULT_CACHE_DURATION)) if isinstance(value, DontCache): value = cast(T, value.unwrap()) conn.set(key, json.dumps(value), ex=cache_duration) return value
def command(self): if not self.CONFIG: self._load_config() self.CONFIG = pylonsconfig self.resource_url_tag = self.CONFIG.get( "googleanalytics_resource_prefix", DEFAULT_RESOURCE_URL_TAG) self.recent_view_days = asint( self.CONFIG.get("googleanalytics.recent_view_days", DEFAULT_RECENT_VIEW_DAYS)) # funny dance we need to do to make sure we've got a # configured session model.Session.remove() model.Session.configure(bind=model.meta.engine) self.parse_and_save()
def run(ctx, host, port, disable_reloader, threaded, extra_files, processes, ssl_cert, ssl_key): u"""Runs the Werkzeug development server""" # Reloading use_reloader = not disable_reloader config_extra_files = tk.aslist( config.get(u"ckan.devserver.watch_patterns")) extra_files = list(extra_files) + [config[u"__file__"] ] + config_extra_files # Threads and processes threaded = threaded or tk.asbool(config.get(u"ckan.devserver.threaded")) processes = processes or tk.asint( config.get(u"ckan.devserver.multiprocess", 1)) if threaded and processes > 1: tk.error_shout(u"Cannot have a multithreaded and multi process server") raise click.Abort() # SSL cert_file = ssl_cert or config.get('ckan.devserver.ssl_cert') key_file = ssl_key or config.get('ckan.devserver.ssl_key') if cert_file and key_file: if cert_file == key_file == 'adhoc': ssl_context = 'adhoc' else: ssl_context = (ssl_cert, ssl_key) else: ssl_context = None log.info(u"Running CKAN on {scheme}://{host}:{port}".format( scheme='https' if ssl_context else 'http', host=host, port=port)) run_simple( host, port, ctx.obj.app, use_reloader=use_reloader, use_evalex=True, threaded=threaded, processes=processes, extra_files=extra_files, ssl_context=ssl_context, )
def send_login_email(email_addr, user_id): # Generate key pure_login_key = binascii.hexlify( os.urandom(tk.asint(tk.config.get('ckan.emailauth.login_key_size', 20)))) # Record entry = db.AutoLoginKey() entry.key_digest = hashlib.sha256( (pure_login_key + email_addr).encode('utf-8')).hexdigest() entry.user_id = user_id entry.src_email = email_addr entry.save() # Generate content login_page = tk.config.get('ckan.site_url') + tk.url_for(controller='user', action='login')[0] login_link = '%s?login=%s&email=%s' % (login_page, pure_login_key, urllib.quote(email_addr)) email_sender = tk.config.get('ckan.emailauth.email_sender', 'login') email_content = tk.config.get( 'ckan.emailauth.email_content', ''' <html> <head></head> <body> Click <a href="%s">here</a> to log in to SAAB. </body> </html> ''') % login_link # Build email_msg = MIMEMultipart.MIMEMultipart() email_msg['From'] = email_sender email_msg['To'] = email_addr email_msg['Date'] = emailutils.formatdate(localtime=True) email_msg['Subject'] = tk.config.get('ckan.emailauth.email_subject', 'Your SAAB Login Link') # Attach content email_msg.attach(MIMEText.MIMEText(email_content, 'html')) # Send smtp = SMTP() smtp.connect() smtp.sendmail(email_sender, email_addr, email_msg.as_string()) smtp.close()
log = logging.getLogger(__name__) ###reading apis configs from CKAN config, defaults to GFBio Apis #autocomplete api-endpoint AUTOCOMPLETE_API = config.get( 'ckan.tag_restriction.autocomplete_api', 'https://terminologies.gfbio.org/api/terminologies/suggest?query={}&limit={}' ) #search api-endpoint SEARCH_API = config.get( 'ckan.tag_restriction.search_api', 'https://terminologies.gfbio.org/api/terminologies/search?query={}') #minimum tag charachters for calling autocomplete api AUTOCOMPLETE_MIN_CHARS = toolkit.asint( config.get('ckan.tag_restriction.autocomplete_min_chars', 4)) #autocomplete results filed in api response AUTOCOMPLETE_RESULT_FIELD = config.get( 'ckan.tag_restriction.autocomplete_results_field', 'results') #autocomplete tag label filed in api response AUTOCOMPLETE_LABEL_FIELD = config.get( 'ckan.tag_restriction.autocomplete_label_field', 'label') #search results filed in api response SEARCH_RESULT_FIELD = config.get('ckan.tag_restriction.search_results_field', 'results') class Tag_RestrictionPlugin(plugins.SingletonPlugin):
from logging import getLogger import urlparse import requests import pylons.config as config import ckan.logic as logic import ckan.lib.base as base from ckan.common import _ from ckan.plugins.toolkit import asint log = getLogger(__name__) MAX_FILE_SIZE = asint(config.get('ckan.resource_proxy.max_file_size', 1024**2)) CHUNK_SIZE = asint(config.get('ckan.resource_proxy.chunk_size', 4096)) def proxy_resource(context, data_dict): ''' Chunked proxy for resources. To make sure that the file is not too large, first, we try to get the content length from the headers. If the headers to not contain a content length (if it is a chinked response), we only transfer as long as the transferred data is less than the maximum file size. ''' resource_id = data_dict['resource_id'] log.info('Proxify resource {id}'.format(id=resource_id)) try: resource = logic.get_action('resource_show')(context, {'id': resource_id}) except logic.NotFound:
from logging import getLogger import urlparse import requests import pylons.config as config import ckan.logic as logic import ckan.lib.base as base from ckan.common import _ import ckan.plugins.toolkit as toolkit log = getLogger(__name__) MAX_FILE_SIZE = toolkit.asint( config.get('ckan.resource_proxy.max_file_size', 1024 * 1024)) CHUNK_SIZE = 512 def proxy_resource(context, data_dict): ''' Chunked proxy for resources. To make sure that the file is not too large, first, we try to get the content length from the headers. If the headers to not contain a content length (if it is a chinked response), we only transfer as long as the transferred data is less than the maximum file size. ''' resource_id = data_dict['resource_id'] log.info('Proxify resource {id}'.format(id=resource_id)) try: resource = logic.get_action('resource_show')(context, {'id': resource_id}) except logic.NotFound:
def _max_editors(): '''Return the maximum number of editors allowed for this site (int). ''' return toolkit.asint(config.get('ckan.express.max_editors', 3))
def _get_remote_res_max_size(): return tk.asint( tk.config.get("ckanext.resource_indexer.max_remote_size", 4)) * 1024 * 1024
def create_thumbnail(package_id, resource_id=None, width=None, height=None): '''Creates a thumbnail in a dataset and returns its url :rtype: string ''' if c.user == None or len(c.user) == 0: return None if width == None: cfg_width = config.get('ckan.datasetthumbnail.thumbnail_width', 140) width = toolkit.asint(cfg_width) if height == None: cfg_height = config.get('ckan.datasetthumbnail.thumbnail_height', int(width * 1.415)) height = toolkit.asint(cfg_height) package = toolkit.get_action('package_show')(context={ 'ignore_auth': True }, data_dict={ 'id': package_id }) resource = None if resource_id != None: resource = toolkit.get_action('resource_show')(context={ 'ignore_auth': True }, data_dict={ 'id': resource_id }) if resource == None: for pkg_resource in package['resources']: if pkg_resource['format'] == 'JPEG' or pkg_resource[ 'format'] == 'PNG': resource = pkg_resource break if resource != None: if resource['url_type'] == 'upload': auth_header = None if hasattr(c, 'userobj') and hasattr(c.userobj, 'apikey'): auth_header = {'Authorization': c.userobj.apikey} response = requests.get(resource['url'], headers=auth_header, stream=True) else: response = requests.get(resource['url'], stream=True) if response.status_code == 200: original_fp = StringIO( ) #create an in-memory file object in which to save the image for chunk in response.iter_content(1024): original_fp.write(chunk) original_fp.flush() image = None try: image = Image.open(original_fp) except IOError: #if an image can't be parsed from the response... return None image.thumbnail((width, height)) thumbnail_fp = StringIO() thumbnail_fp.name = 'thumbnail.png' image.save(thumbnail_fp, format='PNG') thumbnail_resource = {} thumbnail_resource['package_id'] = package['id'] thumbnail_resource['url'] = 'thumbnail.png' thumbnail_resource['url_type'] = 'upload' thumbnail_resource['format'] = 'png' thumbnail_resource['name'] = 'thumbnail.png' thumbnail_resource['upload'] = _UploadLocalFileStorage( thumbnail_fp) created_resource = toolkit.get_action('resource_create')( context={ 'ignore_auth': True }, data_dict=thumbnail_resource) thumbnail_fp.close() original_fp.close() return created_resource['url'] return None
def _recent_view_days(): return tk.asint( tk.config.get( "googleanalytics.recent_view_days", DEFAULT_RECENT_VIEW_DAYS ) )
from logging import getLogger import urlparse import requests import pylons.config as config import ckan.logic as logic import ckan.lib.base as base from ckan.common import _ from ckan.plugins.toolkit import asint log = getLogger(__name__) MAX_FILE_SIZE = asint(config.get('ckan.resource_proxy.max_file_size', 1024**2)) CHUNK_SIZE = asint(config.get('ckan.resource_proxy.chunk_size', 4096)) def proxy_resource(context, data_dict): ''' Chunked proxy for resources. To make sure that the file is not too large, first, we try to get the content length from the headers. If the headers to not contain a content length (if it is a chinked response), we only transfer as long as the transferred data is less than the maximum file size. ''' resource_id = data_dict['resource_id'] log.info('Proxify resource {id}'.format(id=resource_id)) try: resource = logic.get_action('resource_show')(context, {'id': resource_id}) except logic.NotFound: base.abort(404, _('Resource not found'))
def _make_token(): nbytes = tk.asint(tk.config.get(u"api_token.nbytes", 32)) return token_urlsafe(nbytes)
def get_bulk_size_warning_limit(): return toolkit.asint( config.get("ckanext.bulk.download_size_warning_bytes", 104857600))
def event_description_length(): value = config.get('ckan.mapactionevent.event_description_length', 200) value = toolkit.asint(value) return value
def get_config_int(key, default=0): # type: (str, int) -> int """Get an integer configuration option for this CKAN plugin """ return toolkit.asint(get_config(key, default))
def mobile_depth_threshold(): return tk.asint( tk.config.get(const.CONFIG_MOBILE_THRESHOLD, const.DEFAULT_MOBILE_THRESHOLD))
import logging import ckan.logic as logic import datetime as dt import requests log = logging.getLogger(__name__) render = base.render abort = base.abort NotFound = logic.NotFound NotAuthorized = logic.NotAuthorized get_action = logic.get_action ValidationError = logic.ValidationError MAX_FILE_SIZE = toolkit.asint( config.get('ckan.resource_proxy.max_file_size', 1024**2)) class StaticController(base.BaseController): def cookies(self): return base.render('static/cookies.html') def codeofconduct(self): return base.render('static/codeofconduct.html') def termsandconditions(self): return base.render('static/termsandconditions.html') def privacy(self): return base.render('static/privacy.html')
def location_description_length(): value = config.get('ckan.locationgroup.location_description_length', 200) value = toolkit.asint(value) return value