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
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())]
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]
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)
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)
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)
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)
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')
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)
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)
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
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)
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)
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)
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)
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
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)
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)
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)
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
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
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)
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)
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}
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)
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)]
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
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)
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)
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)