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
