Exemplo n.º 1
0
 def show(self, ver=None, register=None, subregister=None,id=None, id2=None):
     #Create the normal CKAN API Controller
     apiController = CKANApiController()
     #Calls function "show" of the CKAN controller and gets the result
     res = apiController.show(ver,register,subregister,id,id2)
     #Patch the JSON so we remove the urls
     return pathJSON(res)
 def action(self, logic_function, ver=None):
     #Create the normal CKAN API Controller
     apiController = CKANApiController()
     #Calls function "action" of the CKAN controller and gets the result
     res = apiController.action(logic_function, ver)
     #Patch the JSON so we remove the urls
     toolkit.response.content_type = 'application/json'
     return pathJSON(res)
Exemplo n.º 3
0
 def action(self, logic_function, ver=None):
     #Create the normal CKAN API Controller
     apiController = CKANApiController()
     #Calls function "action" of the CKAN controller and gets the result
     res = apiController.action(logic_function,ver)
     #Patch the JSON so we remove the urls
     toolkit.response.content_type = 'application/json'
     return pathJSON(res)
 def show(self,
          ver=None,
          register=None,
          subregister=None,
          id=None,
          id2=None):
     #Create the normal CKAN API Controller
     apiController = CKANApiController()
     #Calls function "show" of the CKAN controller and gets the result
     res = apiController.show(ver, register, subregister, id, id2)
     #Patch the JSON so we remove the urls
     return pathJSON(res)
Exemplo n.º 5
0
    def multisave_groups(self):
        c.error = ''        
        group_id = request.params['group_id']
        
        from ckan.controllers.api import ApiController

        api = ApiController()
        try:
            return api.update(register='group', ver=2, id=group_id)
        except NotAuthorized:
            return '{"status":"Not Authorized", "message":"' + _("Access denied.") + '"}'
        except NotFound:
            return '{"status":"Not Found", "message":"' + _("Group not found.") + '"}'
        except ValidationError:
            return '{"status":"Conflict", "message":"' + _("Validation error.") + '"}'
Exemplo n.º 6
0
    def action(self, api_action, ver=None):
        try:
            function = toolkit.get_action(api_action)
            side_effect_free = getattr(function, 'side_effect_free', False)
            request_data = self._get_request_data(
                try_url_params=side_effect_free)

            capture_api_actions = plugin.GoogleAnalyticsPlugin.capture_api_actions

            # Only send api actions if it is in the capture_api_actions dictionary
            if api_action in capture_api_actions and isinstance(
                    request_data, dict):
                api_action_label = capture_api_actions.get(api_action)

                parameter_value = request_data.get('id', '')
                if parameter_value == '' and 'resource_id' in request_data:
                    parameter_value = request_data['resource_id']
                if parameter_value == '' and 'q' in request_data:
                    parameter_value = request_data['q']
                if parameter_value == '' and 'query' in request_data:
                    parameter_value = request_data['query']
                if parameter_value == '' and 'sql' in request_data:
                    parameter_value = self._alter_sql(request_data['sql'])

                event_action = "{0} - {1}".format(
                    api_action, c.environ['PATH_INFO'].replace('/api/3/', ''))
                event_label = api_action_label.format(parameter_value)
                self._post_analytics(c.user, event_action, event_label,
                                     request_data)
        except Exception as e:
            log.debug(e)
            pass

        return ApiController.action(self, api_action, ver)
Exemplo n.º 7
0
    def action(self, api_action, ver=None):
        try:
            request_data = self._get_action_request_data(api_action)
            parameter_value = self._get_parameter_value(request_data)
            capture_api_actions = ga_api_actions.GoogleAnalyticsPlugin.capture_api_actions
            event_action = ''
            event_label = ''

            # Only send api actions if it is in the capture_api_actions dictionary
            if api_action in capture_api_actions:
                capture_api_action = capture_api_actions.get(api_action)
                event_action = capture_api_action['action'].format(api_action)
                event_label = capture_api_action['label'].format(
                    parameter_value)
            # If catch_all_api_actions is True send api action
            elif ga_api_actions.GoogleAnalyticsPlugin.catch_all_api_actions:
                event_action = api_action
                event_label = parameter_value

            # Only send to google analytics if event_action is set to reduce noise
            if event_action:
                self._post_analytics(c.user, event_action, event_label)

        except Exception as e:
            log.debug(e)
            pass

        return ApiController.action(self, api_action, ver)
 def action(self, logic_function, ver=None):
     if c.environ['SERVER_NAME'] not in ('localhost', '127.0.0.1', '::1'):
         request_query = c.environ.get('paste.parsed_dict_querystring', ({},))[0]
         request_id = request_query.get('query', request_query.get('q', ''))
         request_description = "CKAN API Request"
         _post_analytics(c.user or 'anonymous', 'action', logic_function, request_description, request_id)
     return ApiController.action(self, logic_function, ver)
Exemplo n.º 9
0
    def action(self, logic_function, ver=None):
        try:
            function = logic.get_action(logic_function)
            side_effect_free = getattr(function, "side_effect_free", False)
            request_data = self._get_request_data(
                try_url_params=side_effect_free
            )
            if isinstance(request_data, dict):
                id = request_data.get("id", False)
                resource_id = request_data.get("resource_id", False)
                package_id = request_data.get("resource", {}).get("package_id", False)
                package_id = request_data.get("package_id", package_id)

                if "q" in request_data:
                    id = request_data["q"]
                if "sql" in request_data:
                    id = request_data["sql"]
                if "query" in request_data:
                    id = request_data["query"]
                self._post_analytics(c.user, logic_function, "", [
                                     id, resource_id, package_id])
        except Exception as e:
            log.debug(e)
            pass
        return ApiController.action(self, logic_function, ver)
Exemplo n.º 10
0
 def delete(self, ver=None, register=None,
            subregister=None, id=None, id2=None):
     self._post_analytics(c.user,
                          register +
                          ("_"+str(subregister) if subregister else ""),
                          "delete",
                          id)
     return ApiController.delete(self, ver, register, subregister, id, id2)
 def list(self, ver=None, register=None,
          subregister=None, id=None):
     self._post_analytics(c.user,
                          register +
                          ("_"+str(subregister) if subregister else ""),
                          "list",
                          id)
     return ApiController.list(self, ver, register, subregister, id)
 def delete(self, ver=None, register=None,
            subregister=None, id=None, id2=None):
     self._post_analytics(c.user,
                          register +
                          ("_"+str(subregister) if subregister else ""),
                          "delete",
                          id)
     return ApiController.delete(self, ver, register, subregister, id, id2)
Exemplo n.º 13
0
 def list(self, ver=None, register=None, subregister=None, id=None):
     self._post_analytics(
         c.user,
         register + ("_" + str(subregister) if subregister else ""),
         "list",
         id,
     )
     return ApiController.list(self, ver, register, subregister, id)
Exemplo n.º 14
0
class GAApiController(ApiController):
    # intercept API calls to record via google analytics
    def _post_analytics(self, user, request_obj_type, request_function,
                        request_id):
        if config.get('googleanalytics.id'):
            data_dict = {
                "v": 1,
                "tid": config.get('googleanalytics.id'),
                "cid": hashlib.md5(user).hexdigest(),
                # customer id should be obfuscated
                "t": "event",
                "dh": c.environ['HTTP_HOST'],
                "dp": c.environ['PATH_INFO'],
                "dr": c.environ.get('HTTP_REFERER', ''),
                "ec": "CKAN API Request",
                "ea": request_obj_type + request_function,
                "el": request_id,
            }

            try:
                if converters.asbool(
                        config.get('googleanalytics.activities_tracker',
                                   False)) == True:
                    context = {
                        'model': model,
                        'session': model.Session,
                        'user': c.user
                    }
                    data = {
                        'resource_id': request_id,
                        'event': request_function,
                        'obj_type': request_obj_type,
                    }
                    logic.get_action('resource_tracker_create')(context, data)
            except:
                pass
            plugin.GoogleAnalyticsPlugin.analytics_queue.put(data_dict)

    def action(self, logic_function, ver=None):
        try:
            function = logic.get_action(logic_function)
            side_effect_free = getattr(function, 'side_effect_free', False)
            request_data = self._get_request_data(
                try_url_params=side_effect_free)
            if isinstance(request_data, dict):
                id = request_data.get('id', '')
                if 'q' in request_data:
                    id = request_data['q']
                if 'query' in request_data:
                    id = request_data['query']
                self._post_analytics(c.user, logic_function, '', id)
        except Exception, e:
            log.debug(e)
            pass

        return ApiController.action(self, logic_function, ver)
Exemplo n.º 15
0
 def show(
     self, ver=None, register=None, subregister=None, id=None, id2=None
 ):
     self._post_analytics(
         c.user,
         register + ("_" + str(subregister) if subregister else ""),
         "show",
         id,
     )
     return ApiController.show(self, ver, register, subregister, id, id2)
Exemplo n.º 16
0
    def search(self, ver=None, register=None):
        id = None
        try:
            params = MultiDict(self._get_search_params(request.params))
            if "q" in list(params.keys()):
                id = params["q"]
            if "query" in list(params.keys()):
                id = params["query"]
        except ValueError as e:
            log.debug(str(e))
            pass
        self._post_analytics(c.user, register, "search", id)

        return ApiController.search(self, ver, register)
Exemplo n.º 17
0
class CscGAApiController(ApiController):
    # intercept API calls to record via google analytics
    def _post_analytics(self, user, request_obj_type, request_function,
                        request_id):
        if config.get('googleanalytics.id'):
            data_dict = {
                "v": 1,
                "tid": config.get('googleanalytics.id'),
                "cid": hashlib.md5(user).hexdigest(),
                # customer id should be obfuscated
                "t": "event",
                "dh": c.environ['HTTP_HOST'],
                "dp": c.environ['PATH_INFO'],
                "dr": c.environ.get('HTTP_REFERER', ''),
                "ec": "CKAN API Request",
                "ea": request_obj_type + request_function,
                "el": request_id,
            }
            plugin.CscGAPlugin.analytics_queue.put(data_dict)

    def action(self, logic_function, ver=None):
        try:
            function = get_action(logic_function)
            side_effect_free = getattr(function, 'side_effect_free', False)
            request_data = self._get_request_data(
                try_url_params=side_effect_free)
            if isinstance(request_data, dict):
                id = request_data.get('id', '')
                if 'q' in request_data:
                    id = request_data['q']
                if 'query' in request_data:
                    id = request_data['query']
                self._post_analytics(c.user, logic_function, '', id)
        except Exception, e:
            log.debug(e)
            pass

        return ApiController.action(self, logic_function, ver)
Exemplo n.º 18
0
 def check(request_params, expected_params):
     params = ApiController._get_search_params(request_params)
     assert_equal(params, expected_params)
Exemplo n.º 19
0
 def check(request_params, expected_params):
     params = ApiController._get_search_params(request_params)
     assert_equal(params, expected_params)
Exemplo n.º 20
0
    def update_config(self, config):
        config['ckan.site_title'] = 'CKAN-Drupal'

        url = config['drupal.db_url'] 

        self.engine = create_engine(url, echo=True)
        self.metadata = MetaData(self.engine)

        PACKAGE_NAME_MAX_LENGTH = 100
        PACKAGE_VERSION_MAX_LENGTH = 100

        ApiController.register_action('drupal_package_create',
                                       drupal_package_create)
        ApiController.register_action('drupal_package_update',
                                       drupal_package_update)

        self.package_table = Table('ckan_package', self.metadata,
            Column('nid', types.Integer, unique=True),
            Column('vid', types.Integer, unique=True),
            Column('id', types.Unicode(100), primary_key=True),
            Column('name', types.Unicode(PACKAGE_NAME_MAX_LENGTH),
                   nullable=False, unique=True),
            Column('title', types.UnicodeText),
            Column('version', types.Unicode(PACKAGE_VERSION_MAX_LENGTH)),
            Column('url', types.UnicodeText),
            Column('author', types.UnicodeText),
            Column('author_email', types.UnicodeText),
            Column('maintainer', types.UnicodeText),
            Column('maintainer_email', types.UnicodeText),                      
            Column('notes', types.UnicodeText),
            Column('license_id', types.UnicodeText),
            Column('update_date', types.Integer),
            Column('state', types.UnicodeText),
            Column('completed', types.Boolean),
        )

        self.resource_table = Table(
            'ckan_resource', self.metadata,
            Column('nid', types.Integer),
            Column('vid', types.Integer),
            ## cache of package id to make things easier
            Column('package_id', types.UnicodeText),
            ##
            Column('id', types.Unicode(100), primary_key=True),
            Column('resource_group_id', types.UnicodeText),
            Column('package_id', types.UnicodeText),
            Column('url', types.UnicodeText, nullable=False),
            Column('format', types.UnicodeText),
            Column('description', types.UnicodeText),
            Column('hash', types.UnicodeText),
            Column('position', types.Integer),
            Column('extras', types.UnicodeText),
            )

        self.package_extra_table = Table('ckan_package_extra', self.metadata,
            Column('nid', types.Integer),
            Column('vid', types.Integer),
            Column('id', types.Unicode(100), primary_key=True),
            Column('package_id', types.UnicodeText),
            Column('key', types.UnicodeText),
            Column('value', types.UnicodeText),
        )

        self.metadata.create_all(self.engine)
Exemplo n.º 21
0
from ckan.common import _, c, request, response, config
import ckan.logic as logic
import ckan.model as model
import ckan.lib.base as base
import sqlalchemy
from ckan.controllers.api import ApiController
import requests
import time
import ckan.lib.jsonp as jsonp
import json
from paste.deploy.converters import asbool

get_action = logic.get_action
_check_access = logic.check_access
_or_ = sqlalchemy.or_
api_cntr = ApiController()


def get_dataset_data(context, data_dict):
    model = context['model']

    _check_access('package_autocomplete', context, data_dict)

    limit = data_dict.get('limit', 10)
    q = data_dict['q']
    exc = data_dict.get('except')
    like_q = u"%s%%" % q
    query = model.Session.query(model.Package)
    query = query.filter(model.Package.state == 'active')
    query = query.filter(model.Package.private == False)
    query = query.filter(_or_(model.Package.name.ilike(like_q),
Exemplo n.º 22
0
    def __call__(self, environ, start_response):
        # Save access to tracking_raw
        CustomTrackingController.update(environ['REQUEST_URI'], 'api', environ)

        return ApiController.__call__(self, environ, start_response)
Exemplo n.º 23
0
        self._post_analytics(c.user,
                             register +
                             ("_"+str(subregister) if subregister else ""),
                             "update",
                             id)
        return ApiController.update(self, ver, register, subregister, id, id2)

    def delete(self, ver=None, register=None,
               subregister=None, id=None, id2=None):
        self._post_analytics(c.user,
                             register +
                             ("_"+str(subregister) if subregister else ""),
                             "delete",
                             id)
        return ApiController.delete(self, ver, register, subregister, id, id2)

    def search(self, ver=None, register=None):
        id = None
        try:
            params = MultiDict(self._get_search_params(request.params))
            if 'q' in params.keys():
                id = params['q']
            if 'query' in params.keys():
                id = params['query']
        except ValueError, e:
            log.debug(str(e))
            pass
        self._post_analytics(c.user, register, "search", id)

        return ApiController.search(self, ver, register)
Exemplo n.º 24
0
        return ApiController.delete(self, ver, register, subregister, id, id2)

    def search(self, ver=None, register=None):
        id = None
        try:
            params = MultiDict(self._get_search_params(request.params))
            if 'q' in params.keys():
                id = params['q']
            if 'query' in params.keys():
                id = params['query']
        except ValueError, e:
            log.debug(str(e))
            pass
        self._post_analytics(c.user, register, "search", id)

        return ApiController.search(self, ver, register)


class GAResourceController(PackageController):
    # intercept API calls to record via google analytics
    def _post_analytics(
            self, user, request_obj_type, request_function, request_id):
        if config.get('googleanalytics.id'):
            data_dict = {
                "v": 1,
                "tid": config.get('googleanalytics.id'),
                "cid": hashlib.md5(user).hexdigest(),
                # customer id should be obfuscated
                "t": "event",
                "dh": c.environ['HTTP_HOST'],
                "dp": c.environ['PATH_INFO'],