Example #1
0
    def lookup_output_schema(self, route_name, request_method=None):
        request_method = maybe_list(request_method or DEFAULT_METHODS)
        request_method.append('')

        schemas = []
        for req_method in maybe_list(request_method):
            utility_name = '%s %s' % (route_name, req_method or '')
            view = self.registry.queryUtility(IOutputSchemaView, name=utility_name)
            if view is not None:
                schemas.append(view)
        return schemas
Example #2
0
    def lookup_output_schema(self, route_name, request_method=None):
        request_method = maybe_list(request_method or DEFAULT_METHODS)
        request_method.append('')

        schemas = []
        for req_method in maybe_list(request_method):
            utility_name = '%s %s' % (route_name, req_method or '')
            view = self.registry.queryUtility(IOutputSchemaView,
                                              name=utility_name)
            if view is not None:
                schemas.append(view)
        return schemas
Example #3
0
def construct_sequence_items(name, values):
    maybe_deep_name = name + '.'
    result_sequence = defaultdict(dict)
    for key, value in values.items():
        if not value:
            continue

        if key == name:
            key_first = ''
        elif key.startswith(maybe_deep_name):
            key_first = key.split(maybe_deep_name, 1)[1]
        else:
            continue

        value = maybe_list(value)
        if '.' in key_first:
            maybe_number, second_key = key_first.split('.', 1)
            maybe_number = maybe_integer(maybe_number)
            if maybe_number is not None:
                key = '%s.%s' % (name, second_key)
                result_sequence[maybe_number][key] = value[0]
                continue

        elif key_first:
            maybe_number = maybe_integer(key_first)
            if maybe_number is not None:
                result_sequence[maybe_number][name] = value[0]
                continue

        for i, key_value in enumerate(value):
            result_sequence[i][key] = key_value

    return [v for i, v in sorted(result_sequence.items())]
Example #4
0
def construct_sequence_items(name, values):
    maybe_deep_name = name + '.'
    result_sequence = MissingDict()
    for key, value in values.items():
        if not value:
            continue

        if key == name:
            key_first = ''
        elif key.startswith(maybe_deep_name):
            key_first = key.split(maybe_deep_name, 1)[1]
        else:
            continue

        value = maybe_list(value)
        if '.' in key_first:
            maybe_number, key_second = key_first.split('.', 1)
            maybe_number = maybe_integer(maybe_number)
            if maybe_number is not None:
                key = u'.'.join([name, key_second])
                result_sequence[maybe_number][key] = value[0]
                continue

        elif key_first:
            maybe_number = maybe_integer(key_first)
            if maybe_number is not None:
                result_sequence[maybe_number][name] = value[0]
                continue

        for i, key_value in enumerate(value):
            result_sequence[i][key] = key_value

    result_sequence = result_sequence.items()
    result_sequence.sort()
    return [v for i, v in result_sequence]
Example #5
0
 def register_output_schema(self, view, route_name, request_method):
     for req_method in maybe_list(request_method) or ['']:
         utility_name = '%s %s' % (route_name or '', req_method or '')
         self.registry.registerUtility(
             view,
             provided=IOutputSchemaView,
             name=utility_name)
Example #6
0
    def __call__(self, environ, start_response):
        content_type = get_content_type(environ.get('CONTENT_TYPE'))
        if content_type == 'application/json' and 'wsgi.input' in environ:
            body = environ['wsgi.input'].read()
            if body:
                arguments = []
                body = to_string(body)
                try:
                    body_json = loads(body)
                    for key, values in dict(body_json).items():
                        values = maybe_list(values)
                        for value in values:
                            if value is None:
                                arguments.append('%s=' % key)
                            else:
                                arguments.append('%s=%s' % (key, quote(dump_query_value(value))))
                    body = '&'.join(arguments)
                except (ValueError, UnicodeEncodeError):
                    headers = [('Content-type', 'application/json')]
                    error = HTTPInvalidJSONPayload()
                    start_response(error.status, headers)
                    return format_error_response_to_json(error)

            environ_add_POST(environ, body or '')

        return self.application(environ, start_response)
Example #7
0
def construct_sequence_items(name, values):
    maybe_deep_name = name + '.'
    result_sequence = MissingDict()
    for key, value in values.items():
        if not value:
            continue

        if key == name:
            key_first = ''
        elif key.startswith(maybe_deep_name):
            key_first = key.split(maybe_deep_name, 1)[1]
        else:
            continue

        value = maybe_list(value)
        if '.' in key_first:
            maybe_number, key_second = key_first.split('.', 1)
            maybe_number = maybe_integer(maybe_number)
            if maybe_number is not None:
                key = u'.'.join([name, key_second])
                result_sequence[maybe_number][key] = value[0]
                continue

        elif key_first:
            maybe_number = maybe_integer(key_first)
            if maybe_number is not None:
                result_sequence[maybe_number][name] = value[0]
                continue

        for i, key_value in enumerate(value):
            result_sequence[i][key] = key_value

    result_sequence = result_sequence.items()
    result_sequence.sort()
    return [v for i, v in result_sequence]
Example #8
0
        def callback(context, name, ob):
            config = context.config.with_package(info.module)

            route_name = settings.get('route_name') or getattr(ob, '__view_defaults__', {}).get('route_name')
            if route_name:
                browser_constructor = config.registry.settings.get('browser_constructor')
                if not browser_constructor:
                    browser_settings = dict(
                        (key[8:], value)
                        for key, value in config.registry.settings.items()
                        if key.startswith('browser.') and value)

                    if browser_settings:
                        browser_constructor = BrowserDecorator(browser_settings)
                        config.registry.settings['browser_constructor'] = browser_constructor

                if browser_constructor:
                    decorator = maybe_list(settings.pop('decorator', None))
                    decorator.append(browser_constructor)
                    settings['decorator'] = tuple(decorator)

            if not config.is_production_environ:
                renderer = settings.get('renderer')
                renderer_development_folder = config.settings.get('renderer_development_folder')
                if renderer and renderer_development_folder and ':' in renderer:
                    package_name, path = renderer.split(':', 1)
                    breadcrumbs = path.split(OS_SEP)
                    breadcrumbs[0] = renderer_development_folder
                    settings['renderer'] = '%s:%s' % (package_name, join_path(*breadcrumbs))

            config.add_view(view=ob, **settings)
Example #9
0
    def remove_reference(self, name, expire=MARKER):
        file_path = self.get_reference_path(name)
        temporary_file_path = file_path + '.' + make_uuid_hash()
        move_file(file_path, temporary_file_path, retries=self.retries, retry_errno=self.retry_errno)

        references = self._get_references(temporary_file_path, name='')
        if name in references:
            references.remove(name)

        # Validate if references still exists
        if references:
            if expire is MARKER:
                # Dont use expire, we only need to know if file exists
                expire = None
            for name in references:
                path = self.get_file_path(name)
                if not self._contains(path, expire=expire):
                    references.remove(name)

            if references:
                references = maybe_list(references)
                references.append(b_linesep)

                put_binary_on_file(
                    file_path,
                    binary=bytes_join(b_linesep, references),
                    mode='ab',
                    retries=self.retries,
                    retry_errno=self.retry_errno)

        self._delete_path(temporary_file_path)
Example #10
0
    def set_deform_translation(self, path=None, production_path=None, base_static_path=None):
        def translator(term):
            return get_localizer(get_current_request()).translate(term)

        deform = _import_module('deform')

        path = self.is_production_environ and production_path or path
        if path:
            deform_template_dir = resource_filename(*path.split(':', 1))
            zpt_renderer = deform.ZPTRendererFactory(
                [deform_template_dir],
                translator=translator)
            deform.Form.set_default_renderer(zpt_renderer)

        if base_static_path:
            if not base_static_path.endswith('/'):
                base_static_path += '/'
            for versions in deform.widget.default_resources.values():
                for resources in versions.values():
                    for resource_type, resource in resources.items():
                        new_resources = [
                            r.replace('deform:static/', base_static_path, 1)
                            for r in maybe_list(resource)]

                        if not is_nonstr_iter(resource):
                            resources[resource_type] = new_resources[0]
                        else:
                            resources[resource_type] = tuple(new_resources)

        self.add_translation_dirs('deform:locale')
        if not base_static_path:
            self.add_static_view('deform', 'deform:static')
Example #11
0
File: view.py Project: hjalves/ines
        def callback(context, name, ob):
            route_name = settings.get('route_name')
            if not route_name:
                route_name = getattr(ob, '__view_defaults__',
                                     {}).get('route_name')
            request_method = settings.get('request_method')
            if not request_method:
                request_method = getattr(ob, '__view_defaults__',
                                         {}).get('request_method')

            # Register input schema
            if input_option or use_fields:
                if input_option is not None:
                    if not isinstance(input_option, InputSchemaView):
                        input_view = InputSchemaView(
                            route_name,
                            request_method,
                            schema=input_option,
                            use_fields=use_fields,
                            auto_camelcase=auto_camelcase)
                    else:
                        input_view = input_option
                else:
                    input_view = InputSchemaView(route_name,
                                                 request_method,
                                                 use_fields=use_fields,
                                                 auto_camelcase=auto_camelcase)

                decorator = maybe_list(settings.pop('decorator', None))
                decorator.append(input_view)
                settings['decorator'] = tuple(decorator)

                context.config.register_input_schema(input_view, route_name,
                                                     request_method)

            # Register output schema
            if output_option:
                if not isinstance(output_option, OutputSchemaView):
                    output_view = OutputSchemaView(route_name,
                                                   request_method,
                                                   schema=output_option)
                else:
                    output_view = output_option

                previous_mapper = settings.get('mapper', DefaultViewMapper)

                class OutputViewMapper(previous_mapper):
                    def __call__(self, view):
                        view = super(OutputViewMapper, self).__call__(view)
                        return output_view(view)

                settings['mapper'] = OutputViewMapper

                context.config.register_output_schema(output_view, route_name,
                                                      request_method)

            config = context.config.with_package(info.module)
            config.add_view(view=ob, **settings)
Example #12
0
 def replace_values(self, name, values, expire=MARKER):
     values = maybe_list(values)
     if not values:
         self.remove(name)
     else:
         self.put_binary(
             name,
             binary=NEW_LINE_AS_BYTES.join(values) + NEW_LINE_AS_BYTES,
             expire=expire)
Example #13
0
def lookup_for_route_permissions(registry, introspector_route):
    permissions = {}
    for maybe_view in registry.introspector.related(introspector_route):
        if maybe_view.type_name == 'view':
            for request_method in maybe_list(maybe_view['request_methods']):
                for maybe_permission in registry.introspector.related(maybe_view):
                    if maybe_permission.type_name == 'permission':
                        permissions[request_method] = maybe_permission['value']
                        break
    return permissions
Example #14
0
def lookup_for_route_permissions(registry, introspector_route):
    permissions = {}
    for maybe_view in registry.introspector.related(introspector_route):
        if maybe_view.type_name == 'view':
            for request_method in maybe_list(maybe_view['request_methods']):
                for maybe_permission in registry.introspector.related(maybe_view):
                    if maybe_permission.type_name == 'permission':
                        permissions[request_method] = maybe_permission['value']
                        break
    return permissions
Example #15
0
File: view.py Project: hjalves/ines
        def callback(context, name, ob):
            route_name = settings.get('route_name')
            if not route_name:
                route_name = getattr(ob, '__view_defaults__', {}).get('route_name')
            request_method = settings.get('request_method')
            if not request_method:
                request_method = getattr(ob, '__view_defaults__', {}).get('request_method')

            # Register input schema
            if input_option or use_fields:
                if input_option is not None:
                    if not isinstance(input_option, InputSchemaView):
                        input_view = InputSchemaView(
                            route_name,
                            request_method,
                            schema=input_option,
                            use_fields=use_fields,
                            auto_camelcase=auto_camelcase)
                    else:
                        input_view = input_option
                else:
                    input_view = InputSchemaView(
                        route_name,
                        request_method,
                        use_fields=use_fields,
                        auto_camelcase=auto_camelcase)

                decorator = maybe_list(settings.pop('decorator', None))
                decorator.append(input_view)
                settings['decorator'] = tuple(decorator)

                context.config.register_input_schema(input_view, route_name, request_method)

            # Register output schema
            if output_option:
                if not isinstance(output_option, OutputSchemaView):
                    output_view = OutputSchemaView(
                        route_name,
                        request_method,
                        schema=output_option)
                else:
                    output_view = output_option

                previous_mapper = settings.get('mapper', DefaultViewMapper)
                class OutputViewMapper(previous_mapper):
                    def __call__(self, view):
                        view = super(OutputViewMapper, self).__call__(view)
                        return output_view(view)
                settings['mapper'] = OutputViewMapper

                context.config.register_output_schema(output_view, route_name, request_method)

            config = context.config.with_package(info.module)
            config.add_view(view=ob, **settings)
Example #16
0
    def replace_values(self, name, values, expire=MARKER):
        if not values:
            self.remove(name)
        else:
            values = maybe_list(values)
            values.append(b_linesep)

            self.put_binary(
                name,
                binary=bytes_join(b_linesep, values),
                expire=expire)
Example #17
0
    def add_routes(self, *routes, **kwargs):
        for arguments in routes:
            if not arguments:
                raise ValueError('Define some arguments')
            elif not isinstance(arguments, dict):
                list_arguments = maybe_list(arguments)
                arguments = {'name': list_arguments[0]}
                if len(list_arguments) > 1:
                    arguments['pattern'] = list_arguments[1]

            self.add_route(**arguments)
Example #18
0
    def add_routes(self, *routes, **kwargs):
        for arguments in routes:
            if not arguments:
                raise ValueError('Define some arguments')
            elif not isinstance(arguments, dict):
                list_arguments = maybe_list(arguments)
                arguments = {'name': list_arguments[0]}
                if len(list_arguments) > 1:
                    arguments['pattern'] = list_arguments[1]
                if len(list_arguments) > 2:
                    arguments['permission'] = list_arguments[2]

            self.add_route(**arguments)
Example #19
0
    def create_global_search_options(self, search, tables):
        response = []
        search = clean_unicode(search)
        search_list = search.split()

        for table in maybe_list(tables):
            ignore_columns = getattr(table, '__ignore_on_global_search__', None)
            ignore_ids = getattr(table, '__ignore_ids_on_global_search__', True)

            for column_name in table._sa_class_manager.local_attrs.keys():
                if ((ignore_ids and (column_name == 'id' or column_name.endswith('_id')))
                        or (ignore_columns and column_name in ignore_columns)):
                    continue

                column = getattr(table, column_name)
                if hasattr(column, 'type'):
                    if isinstance(column.type, Enum):
                        for value in column.type.enums:
                            value_to_search = value
                            for s in search_list:
                                try:
                                    idx = value_to_search.index(s)
                                except ValueError:
                                    break
                                else:
                                    value_to_search = value_to_search[idx + len(s):]
                            else:
                                response.append(column == value)

                    elif isinstance(column.type, String):
                        value = create_like_filter(column, search)
                        if value is not None:
                            response.append(value)

                    elif isinstance(column.type, (Numeric, Integer, Date, DateTime)):
                        value = create_like_filter(cast(column, String), search)
                        if value is not None:
                            response.append(value)

                else:
                    clauses = getattr(column, 'clauses', None)
                    if clauses is not None:
                        value = create_like_filter(func.concat(*clauses), search)
                        if value is not None:
                            response.append(value)
                    else:
                        value = create_like_filter(cast(column, String), search)
                        if value is not None:
                            response.append(value)

        return response
Example #20
0
    def add_schema(
            self, pattern, routes_names, route_name=None,
            title=None,
            description=None,
            model=None,
            **view_kwargs):

        if not isinstance(routes_names, dict):
            routes_names = OrderedDict((k, None) for k in maybe_list(routes_names))
        if not routes_names:
            raise Error('schema', 'Define some routes_names')
        if not route_name:
            route_name = '%s_schema' % routes_names.keys()[0]

        view = SchemaView(
            route_name,
            routes_names,
            title=title,
            description=description,
            model=model)
        self.add_schema_manager(view, route_name, pattern, **view_kwargs)
Example #21
0
    def add_schema(self,
                   pattern,
                   routes_names,
                   route_name=None,
                   title=None,
                   description=None,
                   model=None,
                   **view_kwargs):

        if not isinstance(routes_names, dict):
            routes_names = OrderedDict(
                (k, None) for k in maybe_list(routes_names))
        if not routes_names:
            raise Error('schema', 'Define some routes_names')
        if not route_name:
            route_name = '%s_schema' % routes_names.keys()[0]

        view = SchemaView(route_name,
                          routes_names,
                          title=title,
                          description=description,
                          model=model)
        self.add_schema_manager(view, route_name, pattern, **view_kwargs)
Example #22
0
    def __call__(self, environ, start_response):
        content_type = get_content_type(environ.get('CONTENT_TYPE'))
        if content_type == 'application/json' and 'wsgi.input' in environ:
            body = environ['wsgi.input'].read()
            if body:
                arguments = []
                try:
                    body_json = loads(body)
                    for key, values in dict(body_json).items():
                        values = maybe_list(values)
                        value = ','.join(
                            '' if v is None else dump_query_value(v)
                            for v in values)
                        arguments.append('%s=%s' % (force_string(key), value))
                    body = '&'.join(arguments)
                except (ValueError, UnicodeEncodeError):
                    headers = [('Content-type', 'application/json')]
                    error = HTTPInvalidJSONPayload()
                    start_response(error.status, headers)
                    return format_error_to_json(error)

            environ_add_POST(environ, body or '')

        return self.application(environ, start_response)
Example #23
0
    def get_active_jobs(self, application_names=None, attributes=None, order_by=None):
        jobs = {}
        application_names = maybe_list(application_names)
        for domain_name in self.domain_names:
            domain_info = self.config.cache.get(JOBS_REPORT_PATTERN % domain_name, expire=None)
            if not domain_info:
                continue

            for name, info in domain_info.items():
                application_name = get_job_string_application_name(name)
                if not application_names or application_name in application_names:
                    job_info = jobs.get(name)
                    if not job_info:
                        jobs[name] = job_info = {}
                        apijob = get_job(name)
                        if not apijob:
                            continue

                        job_info['key'] = name
                        job_info['application_name'] = application_name
                        job_info['description'] = apijob.title

                    info_next = from_timestamp(info['next'])
                    if info_next:
                        added_info_next = job_info.get('next_date')
                        if not added_info_next or added_info_next > info_next:
                            job_info['next_date'] = info_next

                    info_start = from_timestamp(info['start'])
                    if not job_info.get('start_date') or info_start < job_info['start_date']:
                        job_info['start_date'] = info_start

                    called = job_info.setdefault('called', [])
                    if info.get('called'):
                        called.extend(from_timestamp(d) for d in info['called'])
                        called.sort()
                    job_info['called_length'] = len(called)

                    if called:
                        last_date = job_info.get('last_date')
                        if not last_date:
                            job_info['last_date'] = called[-1]
                        elif called[-1] > last_date:
                            job_info['last_date'] = called[-1]

                    if not job_info.get('active'):
                        job_info['active'] = info['active']

        # Give SQLAlchemy like response
        response = []
        attributes = tuple(maybe_list(attributes) or ('application_name', ))
        for info in jobs.values():
            response.append(
                lightweight_named_tuple('result', attributes)
                (tuple(info.get(key) for key in attributes)))

        if order_by:
            column = order_by.column_name
            sort_with_none(response, key=column, reverse=order_by.descendant)
        else:
            sort_with_none(response, key='description')

        return response
Example #24
0
    def get_schema_nodes(self, request):
        cache_key = 'schema build cache %s' % self.schema_route_name
        schema_expire_cache = request.settings.get('schema_expire_cache', MARKER)
        nodes = request.cache.get(cache_key, MARKER, expire=schema_expire_cache)
        if nodes is MARKER:
            nodes = defaultdict(dict)
            global_types = defaultdict(list)
            global_models = defaultdict(list)
            keep_types_keys = defaultdict(set)
            keep_models_keys = defaultdict(set)
            to_translate = defaultdict(list)

            for route_name in self.get_route_names():
                info = self.get_route_info(request, route_name)
                if not info:
                    continue

                intr_route, url, url_keys = info
                url_keys = [camelcase(k) for k in url_keys]
                schemas = request.registry.config.lookup_input_schema(route_name, self.request_methods)
                schemas.extend(request.registry.config.lookup_output_schema(route_name, self.request_methods))

                for schema in schemas:
                    fields = []
                    types = defaultdict(list)
                    models = defaultdict(list)

                    if schema.schema:
                        details = self.construct_structure(
                            request,
                            schema.schema,
                            schema.schema_type,
                            types,
                            models,
                            to_translate)

                        if isinstance(details, dict):
                            fields.append(details)
                        else:
                            fields.extend(details)

                    if schema.schema_type == 'request' and schema.fields_schema:
                        details = self.construct_structure(
                            request,
                            schema.fields_schema,
                            schema.schema_type,
                            types,
                            models,
                            to_translate)

                        if isinstance(details, dict):
                            fields.append(details)
                        else:
                            fields.extend(details)

                    if schema.route_name != self.csv_route_name:
                        key = schema.request_method.lower()
                        if key == 'get' and schema.route_name == self.list_route_name:
                            key = 'list'
                    else:
                        key = 'csv'

                    nodes[key][schema.schema_type] = fields
                    nodes[key]['routeName'] = route_name
                    nodes[key]['method'] = schema.request_method.upper()
                    nodes[key]['url'] = url
                    nodes[key]['urlKeys'] = url_keys
                    nodes[key]['renderer'] = schema.renderer.lower()

                    if types:
                        keep_types_keys[key].update(types.keys())
                        for k, values in types.items():
                            global_types[k].extend(values)
                    if models:
                        keep_models_keys[key].update(models.keys())
                        for k, values in models.items():
                            global_models[k].extend(values)

            if global_types:
                if to_translate:
                    to_translate['fieldTypes'] = defaultdict(set)
                nodes['fieldTypes'] = lookup_common_fields(
                    global_types,
                    to_translate,
                    ignore_key='fieldType',
                    is_field_type=True)
                nodes['keep_types_keys'] = keep_types_keys

            if global_models:
                if to_translate:
                    to_translate['models'] = defaultdict(set)
                nodes['models'] = lookup_common_fields(global_models, to_translate, ignore_key='model')
                nodes['keep_models_keys'] = keep_models_keys

            if to_translate:
                nodes['to_translate'] = to_translate

            request.cache.put(cache_key, nodes, expire=schema_expire_cache)

        permissions_cache = {}
        types_keys = set()
        types = nodes.pop('fieldTypes', None)
        keep_types_keys = nodes.pop('keep_types_keys', None)
        models_keys = set()
        models = nodes.pop('models', None)
        keep_models_keys = nodes.pop('keep_models_keys', None)

        to_translate = nodes.pop('to_translate', None)
        fields_translation = {}
        models_translation = {}
        if to_translate:
            translator = request.translator
            fields_translation = to_translate.pop('fieldTypes', fields_translation)
            models_translation = to_translate.pop('models', fields_translation)

        for key, details in nodes.items():
            route_name = details['routeName']
            if route_name not in permissions_cache:
                info = self.get_route_info(request, route_name)
                permissions_cache[route_name] = lookup_for_route_permissions(request.registry, info[0])

            method_permissions = maybe_list(permissions_cache[route_name].get(details['method']))
            if not self.validate_permission(request, method_permissions):
                nodes.pop(key)
                continue

            if keep_types_keys:
                types_keys.update(keep_types_keys[key])
            if keep_models_keys:
                models_keys.update(keep_models_keys[key])

        if types_keys:
            nodes['fieldTypes'] = {}
            for k in types_keys:
                nodes['fieldTypes'][k] = details = types[k]
                field_fields = fields_translation.get(k)
                if field_fields:
                    for field in field_fields:
                        if field == 'options':
                            for option in details[field]:
                                if option['text']:
                                    option['text'] = translator(option['text'])
                        else:
                            details[field] = translator(details[field])

        if models_keys:
            nodes['models'] = {}
            for k in models_keys:
                nodes['models'][k] = details = models[k]
                model_fields = models_translation.get(k)
                if model_fields:
                    for field in model_fields:
                        if field == 'options':
                            for option in details[field]:
                                if option['text']:
                                    option['text'] = translator(option['text'])
                        else:
                            details[field] = translator(details[field])

        if to_translate:
            for key, values in to_translate.items():
                for value in values:
                    text_value = value.get(key)
                    if text_value:
                        value[key] = translator(text_value)
                        print(text_value, value[key])

        return nodes
Example #25
0
    def _lookup_columns(self, table, attributes, active=None, active_tables=None, external=None, active_query=None):
        relate_with = set()
        if not attributes:
            columns = list(table.__table__.c.values())

            if active_tables:
                if active is None:
                    relate_with.update(t.__tablename__ for t in maybe_list(active_tables))

                column = self.get_active_attribute(active_tables, active=active, active_query=active_query)
                relate_with.update(t.name for t in get_object_tables(column))
                columns.append(column)
        else:
            external_names = []
            external_methods = {}
            external_attributes = defaultdict(lambda: defaultdict(list))
            if external:
                for external_table, external_method in external.items():
                    if isinstance(external_table, AliasedClass):
                        tablename = external_table.name.parent.name
                    else:
                        tablename = external_table.__tablename__

                    external_names.append((tablename, len(tablename)))
                    external_methods[tablename] = external_method
                external_names.sort(reverse=True)

            columns = []
            for attribute in maybe_list(attributes):
                if isinstance(attribute, str):
                    column = getattr(table, attribute, None)
                else:
                    column = attribute

                if column is not None:
                    relate_with.update(t.name for t in get_object_tables(column))
                    columns.append(column)

                elif active_tables and attribute == 'active':
                    if active is None:
                        relate_with.update(t.__tablename__ for t in maybe_list(active_tables))

                    column = self.get_active_attribute(active_tables, active=active, active_query=active_query)
                    relate_with.update(t.name for t in get_object_tables(column))
                    columns.append(column)

                else:
                    for name, name_length in external_names:
                        if attribute[:name_length] == name:
                            # Index for posterior insert
                            external_attributes[name][attribute[name_length + 1:]].append(len(columns))
                            columns.append(attribute)
                            break
                    else:
                        raise AttributeError('Missing column attribute "%s" on "%s"' % (attribute, self.__api_name__))

            if external_attributes:
                for name, name_attributes in external_attributes.items():
                    external_columns = external_methods[name](name_attributes.keys(), active=active)
                    if external_columns:
                        relate_with.update(external_columns.relate_with)
                        relate_with.add(name)

                        for column in external_columns:
                            label_name = '%s_%s' % (name, column.key)
                            for column_idx in name_attributes[column.key]:
                                columns[column_idx] = column.label(label_name)

        return LookupAtributes(columns, relate_with)
Example #26
0
    def _lookup_order_by(self, table, attributes, active=None, active_tables=None, external=None, active_query=None):
        order_by = []
        relate_with = set()

        external_names = []
        external_methods = {}
        external_order_by = defaultdict(list)
        if external:
            for external_table, external_method in external.items():
                if isinstance(external_table, AliasedClass):
                    tablename = external_table.name.parent.name
                else:
                    tablename = external_table.__tablename__

                external_names.append((tablename, len(tablename)))
                external_methods[tablename] = external_method
            external_names.sort(reverse=True)

        for attribute in maybe_list(attributes):
            as_desc = False
            if isinstance(attribute, OrderBy):
                as_desc = attribute.descendant
                attribute = attribute.column_name

            elif attribute.lower().endswith(' desc'):
                attribute = attribute[:-5]
                as_desc = True

            elif attribute.lower().endswith(' asc'):
                attribute = attribute[:-4]

            column = getattr(table, attribute, None)
            if column is not None:
                relate_with.update(t.name for t in get_object_tables(column))
                if as_desc:
                    order_by.append(postgresql_non_ascii_and_lower(column, as_text=False).desc())
                else:
                    order_by.append(postgresql_non_ascii_and_lower(column, as_text=False))

            elif active_tables and attribute == 'active':
                if active is None:
                    relate_with.update(t.__tablename__ for t in maybe_list(active_tables))

                column = self.get_active_attribute(active_tables, active=active, active_query=active_query)
                relate_with.update(t.name for t in get_object_tables(column))
                if as_desc:
                    order_by.append(column.desc())
                else:
                    order_by.append(column)

            else:
                for name, name_length in external_names:
                    if attribute[:name_length] == name:
                        external_order_by[name].append((
                            attribute[name_length + 1:],  # +1 = underscore
                            len(order_by),  # Index for posterior insert
                            attribute,
                            as_desc))
                        order_by.append(attribute)
                        break
                else:
                    raise AttributeError('Missing order by attribute "%s" on "%s"' % (attribute, self.__api_name__))

        if external_order_by:
            for name, name_attributes in external_order_by.items():
                external_keys = [k[0] for k in name_attributes]
                external_columns = external_methods[name](external_keys, active=active)
                if external_columns:
                    relate_with.update(external_columns.relate_with)
                    relate_with.add(name)

                    for i, column in enumerate(external_columns):
                        attribute_name, column_idx, label_name, as_desc = name_attributes[i]
                        column = column.label(label_name)

                        if as_desc:
                            order_by[column_idx] = column.desc()
                        else:
                            order_by[column_idx] = column

        return LookupAtributes(order_by, relate_with)
Example #27
0
    def __call__(self, context, request):
        requests = []
        folders = MissingList()
        folders_descriptions = {}
        config = request.registry.config

        for schema_view in request.registry.getAllUtilitiesRegisteredFor(ISchemaView):
            # Make route for url
            schema_route = request.registry.introspector.get('routes', schema_view.route_name)
            if schema_route is not None:
                # Schema permission
                headers = set()
                permissions = lookup_for_route_permissions(request.registry, schema_route)
                method_permissions = maybe_list(permissions.get('GET'))
                for method_permission in method_permissions:
                    if method_permission not in (Everyone, NotAuthenticated):
                        headers.add('Authorization: Token {{token}}')
                        break

                request_id = self.new_unique_id()
                requests.append({
                    'id': request_id,
                    'headers': '\n'.join(headers),
                    'url': request.route_url(schema_view.route_name),
                    'preRequestScript': '',
                    'pathVariables': {},
                    'method': u'GET',
                    'data': [],
                    'dataMode': 'params',
                    'version': 2,
                    'tests': '',
                    'currentHelper': 'normal',
                    'helperAttributes': {},
                    'time': self.collection_time,
                    'name': u'Schema: %s' % schema_view.title,
                    'description': schema_view.description or '',
                    'collectionId': self.collection_id,
                    'responses': [],
                    'owner': 0,
                    'synced': False})
                folders[schema_view.title].append(request_id)
                folders_descriptions[schema_view.title] = schema_view.description

            for route_name, request_methods in schema_view.routes_names.items():
                # Make route for url
                intr_route = request.registry.introspector.get('routes', route_name)
                if intr_route is None:
                    continue
                route = intr_route['object']
                permissions = lookup_for_route_permissions(request.registry, intr_route)
                params = dict((k, '{{%s}}' % camelcase(k)) for k in lookup_for_route_params(route))
                url = '%s%s' % (request.application_url, unquote(route.generate(params)))

                schemas_by_methods = MissingList()
                for schema in config.lookup_input_schema(route_name, request_methods):
                    for request_method in maybe_list(schema.request_method) or DEFAULT_METHODS:
                        schemas_by_methods[request_method].append(schema)
                for schema in config.lookup_output_schema(route_name, request_methods):
                    for request_method in maybe_list(schema.request_method) or DEFAULT_METHODS:
                        schemas_by_methods[request_method].append(schema)

                for request_method, schemas in schemas_by_methods.items():
                    title = None
                    description = None
                    schema_data = []
                    tests = []

                    for schema in schemas:
                        if schema.schema_type == 'request':
                            if schema.schema:
                                schema_data.extend(
                                    self.construct_data(request_method, schema.schema))
                            if schema.fields_schema:
                                schema_data.extend(
                                    self.construct_data(request_method, schema.fields_schema))

                        if schema.schema and not title:
                            title = schema.schema.title
                        if schema.schema and not description:
                            description = schema.schema.description

                        variables = getattr(schema.schema, 'postman_environment_variables', None)
                        if variables:
                            for environment_key, response_key in variables.items():
                                environment_key = camelcase(environment_key)
                                response_key = camelcase(response_key)
                                tests.append(
                                    'if (answer.%s){ postman.setEnvironmentVariable("%s", answer.%s); }'
                                    % (response_key, environment_key, response_key))

                    if tests:
                        tests.insert(0, 'var answer = JSON.parse(responseBody);')

                    # Input params
                    method_url = url
                    request_schema_data = []
                    request_method = request_method.upper()
                    if request_method == 'GET':
                        queries = []
                        for url_param in schema_data:
                            if url_param['value']:
                                queries.append(
                                    '%s=%s'
                                    % (quote(url_param['key']), quote(url_param['value'])))
                            else:
                                queries.append(quote(url_param['key']))
                        if queries:
                            method_url = '%s?%s' % (method_url, '&'.join(queries))
                    else:
                        request_schema_data = schema_data

                    # Method permission
                    headers = set()
                    method_permissions = maybe_list(permissions.get(request_method))
                    for method_permission in method_permissions:
                        if method_permission not in (Everyone, NotAuthenticated):
                            headers.add('Authorization: Token {{token}}')
                            break

                    if not title:
                        title = route_name.replace('_', ' ').title()

                    request_id = self.new_unique_id()
                    requests.append({
                        'id': request_id,
                        'headers': '\n'.join(headers),
                        'url': method_url,
                        'preRequestScript': '',
                        'pathVariables': {},
                        'method': request_method,
                        'data': request_schema_data,
                        'dataMode': 'params',
                        'version': 2,
                        'tests': '\n'.join(tests),
                        'currentHelper': 'normal',
                        'helperAttributes': {},
                        'time': self.collection_time,
                        'name': title,
                        'description': description or '',
                        'collectionId': self.collection_id,
                        'responses': [],
                        'owner': 0,
                        'synced': False})
                    folders[schema_view.title].append(request_id)

        response_folders = []
        for key, requests_ids in folders.items():
            response_folders.append({
                'id': self.new_unique_id(),
                'name': key,
                'description': folders_descriptions.get(key) or '',
                'order': requests_ids,
                'collection_name': self.title,
                'collection_id': self.collection_id,
                'collection_owner': '',
                'write': True})

        return {
            'id': self.collection_id,
            'name': self.title,
            'description': self.description or '',
            'timestamp': self.collection_time,
            'synced': False,
            'owner': '',
            'subscribed': False,
            'remoteLink': '',
            'public': False,
            'write': True,
            'order': [],
            'folders': response_folders,
            'requests': requests}
Example #28
0
        def callback(context, name, ob):
            view_defaults_settings = getattr(ob, '__view_defaults__', {})

            route_name = settings.get('route_name') or view_defaults_settings.get('route_name')
            request_method = settings.get('request_method') or view_defaults_settings.get('request_method')
            renderer = settings['renderer'] = (
                settings.get('renderer')
                or view_defaults_settings.get('renderer')
                or 'json')

            if not context.config.is_production_environ:
                renderer = settings.get('renderer')
                renderer_development_folder = context.config.settings.get('renderer_development_folder')
                if renderer and renderer_development_folder and ':' in renderer:
                    package_name, path = renderer.split(':', 1)
                    breadcrumbs = path.split(OS_SEP)
                    breadcrumbs[0] = renderer_development_folder
                    settings['renderer'] = '%s:%s' % (package_name, join_path(*breadcrumbs))

            # Register input schema
            if input_option or use_fields:
                if input_option is not None:
                    if not isinstance(input_option, InputSchemaView):
                        input_view = InputSchemaView(
                            route_name,
                            request_method,
                            renderer,
                            schema=input_option,
                            use_fields=use_fields,
                            auto_camelcase=auto_camelcase)
                    else:
                        input_view = input_option
                else:
                    input_view = InputSchemaView(
                        route_name,
                        request_method,
                        renderer,
                        use_fields=use_fields,
                        auto_camelcase=auto_camelcase)

                decorator = maybe_list(settings.pop('decorator', None))
                decorator.append(input_view)
                settings['decorator'] = tuple(decorator)

                context.config.register_input_schema(input_view, route_name, request_method)

            # Register output schema
            if output_option:
                if not isinstance(output_option, OutputSchemaView):
                    output_view = OutputSchemaView(
                        route_name,
                        request_method,
                        renderer,
                        schema=output_option)
                else:
                    output_view = output_option

                previous_mapper = settings.get('mapper', DefaultViewMapper)

                class OutputViewMapper(previous_mapper):
                    def __call__(self, view):
                        view = super(OutputViewMapper, self).__call__(view)
                        return output_view(view)
                settings['mapper'] = OutputViewMapper

                context.config.register_output_schema(output_view, route_name, request_method)

            config = context.config.with_package(info.module)
            config.add_view(view=ob, **settings)
Example #29
0
 def __init__(self, length, reverse=False, startswith=None):
     self.length = int(length)
     self.reverse = reverse
     self.startswith = [str(n) for n in maybe_list(startswith)]
Example #30
0
    def __call__(self, context, request):
        nodes = MissingDict()
        requested_methods = [key.lower() for key in request.GET.keys()]

        types = MissingList()
        models = MissingList()
        for route_name, request_methods in self.routes_names.items():
            route_methods = []
            for request_method in maybe_list(request_methods
                                             or DEFAULT_METHODS):
                if not requested_methods or request_method.lower(
                ) in requested_methods:
                    route_methods.append(request_method)
            if not route_methods:
                continue

            intr_route = request.registry.introspector.get(
                'routes', route_name)
            if intr_route is None:
                continue
            route = intr_route['object']
            params = dict((k, '{{%s}}' % camelcase(k))
                          for k in lookup_for_route_params(route))
            url = '%s%s' % (request.application_url,
                            unquote(route.generate(params)))

            schemas = request.registry.config.lookup_input_schema(
                route_name, route_methods)
            schemas.extend(
                request.registry.config.lookup_output_schema(
                    route_name, route_methods))
            for schema in schemas:
                fields = []
                if schema.schema:
                    details = self.construct_structure(request, schema.schema,
                                                       schema.schema_type,
                                                       types, models)
                    if isinstance(details, dict):
                        fields.append(details)
                    else:
                        fields.extend(details)

                if schema.schema_type == 'request' and schema.fields_schema:
                    details = self.construct_structure(request,
                                                       schema.fields_schema,
                                                       schema.schema_type,
                                                       types, models)
                    if isinstance(details, dict):
                        fields.append(details)
                    else:
                        fields.extend(details)

                name = camelcase('%s_%s' %
                                 (schema.request_method, schema.route_name))
                nodes[name][schema.schema_type] = fields
                nodes[name]['method'] = schema.request_method.upper()
                nodes[name]['url'] = url

        nodes['fieldTypes'] = lookup_for_common_fields(types,
                                                       ignore_key='fieldType')
        nodes['models'] = lookup_for_common_fields(models, ignore_key='model')
        return nodes
Example #31
0
 def register_output_schema(self, view, route_name, request_method):
     for req_method in maybe_list(request_method) or ['']:
         utility_name = '%s %s' % (route_name or '', req_method or '')
         self.registry.registerUtility(view,
                                       provided=IOutputSchemaView,
                                       name=utility_name)
Example #32
0
 def validate_permission(self, request, permissions):
     permissions = maybe_list(permissions)
     if request.authenticated:
         return any((p in permissions for p in request.authenticated.get_principals()))
     else:
         return bool(Everyone in permissions or NotAuthenticated in permissions)
Example #33
0
    def create_message(
            self,
            subject,
            recipients,
            body=None,
            html=None,
            sender=None,
            cc=None,
            bcc=None,
            reply_to=None,
            content_charset='utf-8',
            attachments=None,
            message_id=None):

        force_development_email = None
        if not self.request.is_production_environ:
            force_development_email = self.settings.get('force_development_email') or None

        if body:
            body = to_string(body, encoding=content_charset)
            if not html:
                html = body.replace(NEW_LINE, HTML_NEW_LINE)

        if html:
            html = to_string(html, encoding=content_charset)
            if not html.lower().startswith('<html'):
                html = '<html><body>%s</body></html>' % html

        options = {}
        # FROM sender
        if sender:
            options['sender'] = format_email(
                sender,
                encoding=content_charset,
                force_development_email=force_development_email)

        # Envelope CC
        if cc:
            if isinstance(cc, dict):
                cc = [cc]
            options['cc'] = [
                format_email(e, content_charset, force_development_email=force_development_email)
                for e in maybe_list(cc)]

        # Envelope BCC
        if bcc:
            if isinstance(bcc, dict):
                bcc = [bcc]
            options['bcc'] = [
                format_email(e, content_charset, force_development_email=force_development_email)
                for e in maybe_list(bcc)]

        if not message_id:
            domain = self.settings.get('message_domain') or self.api_session_manager.default_domain
            message_id = make_msgid(make_unique_hash(10), domain)

        extra_headers = {
            'Date': formatdate(localtime=True),
            'Message-ID': to_string(message_id)}

        # Force reply to another email
        if reply_to:
            extra_headers['Reply-To'] = '<%s>' % to_string(reply_to)

        mime_attachments = []
        if attachments:
            if isinstance(attachments, dict):
                attachments = [attachments]
            for attachment in maybe_list(attachments):
                f = attachment.get('file') or attachment['fp']
                filename = to_string(attachment.get('filename') or basename(f.name)).replace(' ', '')
                mimetype = to_string(attachment.get('content_type') or find_mimetype(filename, f))

                f.seek(0)
                mime_attachments.append(self.api_session_manager.attachment_cls(
                    data=f,
                    filename=filename,
                    content_type=mimetype))

        return self.api_session_manager.message_cls(
            subject=to_string(subject, encoding=content_charset),
            html=html,
            body=body,
            recipients=[
                format_email(e, content_charset, force_development_email=force_development_email)
                for e in maybe_list(recipients)],
            attachments=mime_attachments,
            extra_headers=extra_headers,
            **options)