def on_message(self, raw_message):
start = time.time()
message = json_decode(raw_message)
action = message.get("action")
try:
logging.debug(message)
args = message.get("args", {})
method = getattr(self.control, action)
if action=="make_impression":
args["summary"] = self._request_summary()
result = method(self.current_user, **args)
self.send(utils.dumps({"result": result,
"response_id": message.get("request_id")}))
self.log_action(access_log.info, start, action, self.current_user)
self.control._flush()
except Exception as ex:
logging.exception(ex)
error = str(ex)
self.send(utils.dumps({"result": None,
"error" : error,
"response_id": message.get("request_id"),
}))
self.log_action(access_log.error, start, action, self.current_user, error)
self.control._flush(ex)
def test_http_put(self):
fake = Factory.create("en_GB")
client = AsyncHTTPClient(self.io_loop)
for _ in range(10):
data = {"item":{
"email": fake.email(),
"firstname": fake.first_name(),
"lastname": fake.last_name(),
"_password": fake.password()
}}
client.fetch("{}Person".format(BASE_URL), self.stop,
method="PUT",
body=dumps(data),
headers={"Content-Type": "application/json",
"simple-auth-token":"--foo-bar--"})
response = self.wait()
result = loads(response.body.decode("utf-8"))
if result.get("error"):
raise Exception(result["error"])
for _ in range(10):
data = {"item":{
"name": fake.name(),
"dob": fake.date(),
"active": fake.pybool(),
"customer_type": "retail"
}}
client.fetch("{}Customer".format(BASE_URL), self.stop,
method="PUT",
body=dumps(data),
headers={"Content-Type": "application/json",
"simple-auth-token":"--foo-bar--"})
response = self.wait()
result = loads(response.body.decode("utf-8"))
if result.get("error"):
raise Exception(result["error"])
data = {
"item": {
"line1": fake.address(),
"town": fake.city(),
"postcode": fake.postcode(),
"customer_type": "retail"
},
"to_add": [
[
"customers",
"Customer",
result["result"]["id"]
]
]
}
client.fetch("{}Address".format(BASE_URL), self.stop,
method="PUT",
body=dumps(data),
headers={"Content-Type": "application/json",
"simple-auth-token":"--foo-bar--"})
response = self.wait()
result = loads(response.body.decode("utf-8"))
def put(self,resource_path):
"""
Put goes to fetch_and_carry_mixin carry
"""
self.require_json_content()
logging.info("put %s - %s",resource_path, self.json_args)
try:
resources = resource_path.split("/")
resource = resources[0]
id = int(resources[1]) if len(resources) > 1 else None
args = self.json_args
item = args.get("item")
if item is None:
raise Exception("json payload: {item:obj, (to_add:[attr,type,id]]), (to_remove:[attr,type,id]])}")
if item.get("_type") is None and resource in [None,""]:
raise Exception("No resource specified")
if item.get("_type") is None:
item["_type"] = resource
result = {"result": self.control.carry(self.get_current_user,
item,
args.get("to_add"),
args.get("to_remove")), "action": "saved" }
except Exception as ex:
result = {"error": str(ex)}
self.control._flush(ex)
logging.exception(ex)
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(dumps(result))
self.control._flush()
def get_audit_trail(cls, obj):
from sqlalchemy.orm import object_mapper
session = object_session(obj)
obj_mapper = object_mapper(obj)
primary_key = cls._get_instance_pk(obj, obj_mapper)
return session.query(cls).filter(and_(cls.type==obj.__class__.__name__,
cls.ref==utils.dumps(primary_key)))
def on_message(self, raw_message):
start = time.time()
message = json_decode(raw_message)
action = message.get("action")
try:
logging.debug(message)
args = message.get("args", {})
if action == "register":
self.handle_register(message)
elif action == "login":
self.handle_login(message)
else:
method = getattr(self.control, action)
result = method(self.current_user, **args)
self.write_message(utils.dumps({"result": result,
"response_id": message.get("request_id")}))
self.log_action(access_log.info, start, action, self.current_user)
self.control._flush()
except Exception as ex:
logging.exception(ex)
error = str(ex)
self.write_message({"result": None,
"error" : error,
"response_id": message.get("request_id"),
})
self.log_action(access_log.error, start, action, self.current_user, error)
self.control._flush(ex)
def handle_register(self, message):
accl_key = self.control.register(message.get("email"))
self._current_user = accl_key
self.write_message(utils.dumps({
"result":accl_key,
"cookie":self.gen_login_cookie(accl_key),
"cookie_name":self.cookie_name,
"response_id":message.get("request_id")
}))
self._begin_web_session(self.current_user,
self.request.remote_ip,
self.request.headers)
def on_open(self, request):
self.request = request
self.application = self.session.handler.application
logging.info("SockJS opened")
user = self.control.begin_web_session(self.current_user,
self, request.ip, request.headers)
if user:
self.broadcast({
"signal":"user",
"message": user
})
else:
self.send(utils.dumps({'access_error':True}))
self.close(reason="access control failure")
def post(self,resource_path):
"""
Post calls public methods on the control
"""
self.require_json_content()
logging.info("post %s - %s",resource_path, self.json_args)
resources = resource_path.split("/")
action = resources[0]
try:
logging.debug(resource_path)
args = self.json_args or {}
method = getattr(self.control, action)
result = method(self.current_user, **args)
self.write(dumps({"result": result},indent=2))
self.control._flush()
except Exception as ex:
logging.exception(ex)
error = str(ex)
self.write(dumps({"result": None,
"error" : error },indent=2))
self.control._flush(ex)
def delete(self, resource_path):
"""
Put goes to fetch_and_carry_mixin carry
"""
self.require_json_content()
logging.info("delete %s",resource_path)
try:
resources = resource_path.split("/")
resource = resources[0]
id = int(resources[1])
result = {"result": self.control.carry(1,{"id":-id,"_type":resource}) , "action": "deleted"}
except Exception as ex:
result = {"error": str(ex)}
logging.exception(ex)
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(dumps(result))
def get(self, resource_path):
"""
Get goes to fetch_and_carry_mixin fetch or returns the meta data
"""
logging.info("get %s",resource_path)
if resource_path is None or resource_path is "":
self.write(OrderedDict([
("target", "rest-api"),
("version", 1),
("post_methods", self.control._fc_methods),
("model", self.control._fc_description)
]))
else:
try:
resources = resource_path.split("/")
resource = resources[0]
id = resources[1] if len(resources) > 1 else None
limit = int(self.get_argument("limit", 10))
offset = int(self.get_argument("offset", 0))
attr = self.get_argument("attr", None)
filter = self.get_argument("filter", None)
match = self.get_argument("match", None)
order_by = self.get_argument("order_by", None)
order_by_asc = self.get_argument("order_by_asc", 'false').lower() == "true"
depth = int(self.get_argument("depth", 0))
ignore = self.get_argument("ignore",None)
include = self.get_argument("include",None)
if ignore:
ignore = ignore.split(",")
if include:
include = include.split(",")
result = {"result": self.control.fetch(1,resource,id,
attr=attr,
filter=filter,
match=match,
limit=limit,
offset=offset,
order_by=order_by,
order_by_asc=order_by_asc,
depth=depth,
ignore=ignore,
include=include)}
except Exception as ex:
result = {"error": str(ex)}
logging.exception(ex)
self.set_header("Content-Type", "application/json; charset=UTF-8")
self.write(dumps(result))
def open(self):
logging.info("WebSocket opened")
user = self.control._begin_web_session(self.current_user, self,
self.request.remote_ip,
self.request.headers)
if user:
self.broadcast({
"signal":"user",
"message": user,
"ws_version": self.application.settings.get('ws_version',1),
"ws_config": self.application.settings.get("ws_config",{}),
"model": self.control._fc_description,
"methods": self.control._fc_methods,
})
else:
self.write_message(utils.dumps({'access_error':True}))
self.close(reason="access control failure")
def testName(self):
with self.control.session as session:
admin = session.query(model.User).get(1)
foo = model.User(name="foo",_password="******")
bar = model.User(name="bar",_password="******")
session.add_all([foo,bar])
session.flush()
btgs = [model.Battleground(name="Garden of Terror"),
model.Battleground(name="Tomb of the Spider Queen")]
session.add_all(btgs)
lobby = model.Lobby(name="Foo's Lobby",
region=model.Lobby.REGION[0],
battleground=btgs[0])
foo.lobbies.append(lobby)
red = model.Team(name="Red")
lobby.teams.append(red)
blue = model.Team(name="Blue")
lobby.teams.append(blue)
red.members.append(foo)
blue.members.append(bar)
lobby = model.Lobby(name="Foo's other Lobby",
region=model.Lobby.REGION[1],
battleground=btgs[1])
foo.lobbies.append(lobby)
red = model.Team(name="Red")
lobby.teams.append(red)
blue = model.Team(name="Blue")
lobby.teams.append(blue)
red.members.append(foo)
blue.members.append(bar)
blue.members.append(admin)
session.commit()
print(dumps(self.control.get_lobby(1, 1),indent=2))
def _write_attr_ref(self, value):
self._attr_ref = utils.dumps(value)
def get(self):
user = dumps(self.control._get_user(self.current_user))
mode = 'debug' if self.application.settings.get("debug") == 'yes' else 'built'
self.render(self.page, user=user, mode=mode)
def _write_changed(self, value):
self._changed = utils.dumps(value)
def _write_data(self, value):
self._data = utils.dumps(value)
def create_version(cls, obj, session, action, mod_user_id=None):
from sqlalchemy.orm import attributes, object_mapper
from sqlalchemy.orm.exc import UnmappedColumnError
from sqlalchemy.orm.properties import RelationshipProperty # @UnresolvedImport
obj_mapper = object_mapper(obj)
obj_state = attributes.instance_state(obj)
attr = {}
changed = {}
obj_changed = False
if hasattr(obj.__class__, '_no_genoa_audit_'):
return
for om in obj_mapper.iterate_to_root():
primary_keys = [pk.key for pk in om.local_table.primary_key]
for obj_col in om.local_table.c:
# get the value of the
# attribute based on the MapperProperty related to the
# mapped column. this will allow usage of MapperProperties
# that have a different keyname than that of the mapped column.
try:
prop = obj_mapper.get_property_by_column(obj_col)
except UnmappedColumnError:
# in the case of single table inheritance, there may be
# columns on the mapped table intended for the subclass only.
# the "unmapped" status of the subclass column on the
# base class is a feature of the declarative module as of sqla 0.5.2.
continue
if prop.key in primary_keys:
attr[prop.key] = getattr(obj, prop.key)
else:
a, u, d = attributes.get_history(obj, prop.key, PASSIVE_NO_FETCH)
if d:
attr[obj_col.key] = d[0]
changed[prop.key] = getattr(obj, prop.key)
obj_changed = True
elif u:
attr[obj_col.key] = u[0]
elif a:
# if the attribute had no value.
attr[obj_col.key] = a[0]
changed[prop.key] = getattr(obj, prop.key)
obj_changed = True
primary_key = cls._get_instance_pk(obj, obj_mapper)
if obj_changed is True or action=='deleted':
hist = cls(action=action,
type=obj.__class__.__name__,
ref=utils.dumps(primary_key),
data=utils.dumps(attr),
changed=utils.dumps(changed),
mod_user_id=mod_user_id)
session.add(hist)
for prop in obj_mapper.iterate_properties:
if isinstance(prop, RelationshipProperty) and \
prop.direction == MANYTOMANY and \
attributes.get_history(obj, prop.key).has_changes():
a, u, d = attributes.get_history(obj, prop.key, PASSIVE_NO_FETCH)
for item in a:
hist = cls(action='added',
type=obj.__class__.__name__,
ref=utils.dumps(primary_key),
attr=item.__class__.__name__,
attr_ref=utils.dumps(cls._get_instance_pk(item)),
mod_user_id=mod_user_id)
session.add(hist)
for item in d:
hist = cls(action='removed',
type=obj.__class__.__name__,
ref=utils.dumps(primary_key),
attr=item.__class__.__name__,
attr_ref=utils.dumps(cls._get_instance_pk(item)),
mod_user_id=mod_user_id)
session.add(hist)
def process_bind_param(self, value, dialect):
if value is not None:
value = dumps(value)
return value
def broadcast(self, message):
self.write_message(utils.dumps(message))
def broadcast(self, message):
self.send(utils.dumps(message))
def _after_flush(self, session, context):
for item in session.new:
if not isinstance(item, Audit):
Audit.create_version(item, session, 'created', self.accl_key)
else:
self._audit_broadcast_.append(utils.dumps(item._serialize))
