class MethodView(with_metaclass(MethodViewType, View)):
""" Class-based view that dispatches requests to methods decorated with @methodview """
def _match_view(self, method, route_params):
""" Detect a view matching the query
:param method: HTTP method
:param route_params: Route parameters dict
:return: Method
:rtype: Callable|None
"""
method = method.upper()
route_params = frozenset(k for k, v in route_params.items()
if v is not None)
for view_name, info in self.methods_map[method].items():
if info.matches(method, route_params):
return getattr(self, view_name)
else:
return None
def dispatch_request(self, *args, **kwargs):
view = self._match_view(request.method, kwargs)
if view is None:
raise MethodNotAllowed(
description='No view implemented for {}({})'.format(
request.method, ', '.join(kwargs.keys())))
return view(*args, **kwargs)
@classmethod
def route_as_view(cls, app, name, rules, *class_args, **class_kwargs):
""" Register the view with an URL route
:param app: Flask application
:type app: flask.Flask|flask.Blueprint
:param name: Unique view name
:type name: str
:param rules: List of route rules to use
:type rules: Iterable[str|werkzeug.routing.Rule]
:param class_args: Args to pass to object constructor
:param class_kwargs: KwArgs to pass to object constructor
:return: View callable
:rtype: Callable
"""
view = super(MethodView, cls).as_view(name, *class_args,
**class_kwargs)
for rule in rules:
app.add_url_rule(rule, view_func=view)
return view
class RestfulView(with_metaclass(RestfulViewType, MethodView)):
""" Method View that automatically defines the following methods:
Collection:
GET / -> list()
POST / -> create()
Individual item:
GET /<pk> -> get()
PUT /<pk> -> replace()
POST /<pk> -> update()
DELETE /<pk> -> delete()
You just need to specify PK fields
"""
#: List of route parameters used as a primary key.
#: If specified -- then we're working with an individual entry, and if not -- with the whole collection
primary_key = ()
class NodeView(with_metaclass(MethodViewType, View)):
"""
A PostgreSQL Object has so many operaions/functions apart from CRUD
(Create, Read, Update, Delete):
i.e.
- Reversed Engineered SQL
- Modified Query for parameter while editing object attributes
i.e. ALTER TABLE ...
- Statistics of the objects
- List of dependents
- List of dependencies
- Listing of the children object types for the certain node
It will used by the browser tree to get the children nodes
This class can be inherited to achieve the diffrent routes for each of the
object types/collections.
OPERATION | URL | HTTP Method | Method
---------------+-----------------------------+-------------+--------------
List | /obj/[Parent URL]/ | GET | list
Properties | /obj/[Parent URL]/id | GET | properties
Create | /obj/[Parent URL]/ | POST | create
Delete | /obj/[Parent URL]/id | DELETE | delete
Update | /obj/[Parent URL]/id | PUT | update
SQL (Reversed | /sql/[Parent URL]/id | GET | sql
Engineering) |
SQL (Modified | /msql/[Parent URL]/id | GET | modified_sql
Properties) |
Statistics | /stats/[Parent URL]/id | GET | statistics
Dependencies | /dependency/[Parent URL]/id | GET | dependencies
Dependents | /dependent/[Parent URL]/id | GET | dependents
Nodes | /nodes/[Parent URL]/ | GET | nodes
Current Node | /nodes/[Parent URL]/id | GET | node
Children | /children/[Parent URL]/id | GET | children
NOTE:
Parent URL can be seen as the path to identify the particular node.
i.e.
In order to identify the TABLE object, we need server -> database -> schema
information.
"""
operations = dict({
'obj': [
{'get': 'properties', 'delete': 'delete', 'put': 'update'},
{'get': 'list', 'post': 'create'}
],
'nodes': [{'get': 'node'}, {'get': 'nodes'}],
'sql': [{'get': 'sql'}],
'msql': [{'get': 'modified_sql'}],
'stats': [{'get': 'statistics'}],
'dependency': [{'get': 'dependencies'}],
'dependent': [{'get': 'dependents'}],
'children': [{'get': 'children'}]
})
@classmethod
def generate_ops(cls):
cmds = []
for op in cls.operations:
idx = 0
for ops in cls.operations[op]:
meths = []
for meth in ops:
meths.append(meth.upper())
if len(meths) > 0:
cmds.append({
'cmd': op, 'req': (idx == 0),
'with_id': (idx != 2), 'methods': meths
})
idx += 1
return cmds
# Inherited class needs to modify these parameters
node_type = None
# This must be an array object with attributes (type and id)
parent_ids = []
# This must be an array object with attributes (type and id)
ids = []
@classmethod
def get_node_urls(cls):
assert cls.node_type is not None, \
"Please set the node_type for this class ({0})".format(
str(cls.__class__.__name__))
common_url = '/'
for p in cls.parent_ids:
common_url += '<{0}:{1}>/'.format(str(p['type']), str(p['id']))
id_url = None
for p in cls.ids:
id_url = '{0}<{1}:{2}>'.format(
common_url if not id_url else id_url,
p['type'], p['id'])
return id_url, common_url
def __init__(self, **kwargs):
self.cmd = kwargs['cmd']
# Check the existance of all the required arguments from parent_ids
# and return combination of has parent arguments, and has id arguments
def check_args(self, **kwargs):
has_id = has_args = True
for p in self.parent_ids:
if p['id'] not in kwargs:
has_args = False
break
for p in self.ids:
if p['id'] not in kwargs:
has_id = False
break
return has_args, has_id and has_args
def dispatch_request(self, *args, **kwargs):
http_method = flask.request.method.lower()
if http_method == 'head':
http_method = 'get'
assert self.cmd in self.operations, \
'Unimplemented command ({0}) for {1}'.format(
self.cmd,
str(self.__class__.__name__)
)
has_args, has_id = self.check_args(**kwargs)
assert (
self.cmd in self.operations and
(has_id and len(self.operations[self.cmd]) > 0 and
http_method in self.operations[self.cmd][0]) or
(not has_id and len(self.operations[self.cmd]) > 1 and
http_method in self.operations[self.cmd][1]) or
(len(self.operations[self.cmd]) > 2 and
http_method in self.operations[self.cmd][2])
), \
'Unimplemented method ({0}) for command ({1}), which {2} ' \
'an id'.format(http_method,
self.cmd,
'requires' if has_id else 'does not require')
meth = None
if has_id:
meth = self.operations[self.cmd][0][http_method]
elif has_args and http_method in self.operations[self.cmd][1]:
meth = self.operations[self.cmd][1][http_method]
else:
meth = self.operations[self.cmd][2][http_method]
method = getattr(self, meth, None)
if method is None:
return make_json_response(
status=406,
success=0,
errormsg=gettext(
'Unimplemented method ({0}) for this url ({1})'.format(
meth, flask.request.path)
)
)
return method(*args, **kwargs)
@classmethod
def register_node_view(cls, blueprint):
cls.blueprint = blueprint
id_url, url = cls.get_node_urls()
commands = cls.generate_ops()
for c in commands:
cmd = c['cmd'].replace('.', '-')
if c['with_id']:
blueprint.add_url_rule(
'/{0}{1}'.format(
c['cmd'], id_url if c['req'] else url
),
view_func=cls.as_view(
'{0}{1}'.format(
cmd, '_id' if c['req'] else ''
),
cmd=c['cmd']
),
methods=c['methods']
)
else:
blueprint.add_url_rule(
'/{0}'.format(c['cmd']),
view_func=cls.as_view(
cmd, cmd=c['cmd']
),
methods=c['methods']
)
def module_js(self, **kwargs):
"""
This property defines (if javascript) exists for this node.
Override this property for your own logic.
"""
return flask.make_response(
flask.render_template(
"{0}/js/{0}.js".format(self.node_type)
),
200, {'Content-Type': 'application/x-javascript'}
)
def children(self, *args, **kwargs):
"""Build a list of treeview nodes from the child nodes."""
children = []
for module in self.blueprint.submodules:
children.extend(module.get_nodes(*args, **kwargs))
# Return sorted nodes based on label
return make_json_response(
data=sorted(
children, key=lambda c: c['label']
)
)
