def GET(self):
web.header('Content-Type', 'application/json')
#get policy history (used in table display on a Profile page)
policy_history = policies_model.get_policy_history(context.user_id())
#get risks, costs for all months played by a user (used in graphs display on a Profile page)
userid = context.user_id()
scores = db.select('scores',
where='userid=$userid',
order="date ASC",
vars=locals())
scores_result = []
for row in scores:
tmp = {}
for key, value in row.iteritems():
tmp[key] = str(value)
scores_result.append(tmp)
history = json.dumps({
'policy_history': json.dumps(policy_history),
'graph_data': json.dumps(scores_result)
})
if history:
return history
def GET(self):
web.header('Content-Type', 'application/json')
#get policy history (used in table display on a Profile page)
policy_history = policies_model.get_policy_history(context.user_id())
#get risks, costs for all months played by a user (used in graphs display on a Profile page)
userid = context.user_id()
scores = db.select('scores', where='userid=$userid', order="date ASC", vars=locals())
scores_result = []
for row in scores:
tmp = {}
for key, value in row.iteritems():
tmp[key] = str(value)
scores_result.append(tmp)
history = json.dumps(
{
'policy_history': json.dumps(policy_history),
'graph_data': json.dumps(scores_result)
}
)
if history:
return history
def POST(self):
"""
Handles policy updates and returns calendar.
:return: JSON dump
"""
web.header('Content-Type', 'application/json')
payload = json.loads(web.data())
client_date = date_utils.iso8601_to_date(
payload.get('date', '2014-01-06'))
if context.user_id() == 0:
return json.dumps({'success': False, 'messages': ['Unauthorized']})
policy_update = payload.get('policyUpdate')
if client_date.day == 1:
policies_model.commit_policy_update(policy_update, client_date)
else:
return json.dumps({
'success':
False,
'messages': ['Commits are only allowed at the end of month']
})
journal = records(context.user_id())
journal.clear_prophecy(client_date, policy_update)
prophecy = prophet.prophesize(context.user_id(), client_date)
journal.record_prophecy(prophecy)
response = {
'date': client_date.isoformat(),
'policyAccept': True,
'eventAccept': False,
'calendar': journal.get_calendar(client_date)
}
return json.dumps(response)
def POST(self):
web.header('Content-Type', 'application/json')
payload = json.loads(web.data())
client_date = date_utils.iso8601_to_date(
payload.get('date', '2014-01-06'))
if context.user_id() == 0:
return json.dumps({'success': False, 'messages': ['Unauthorized']})
journal = records(context.user_id())
journal.commit_history(client_date)
return json.dumps({'success': True, 'messages': ['Event committed']})
def GET(self, id=0):
"""
If given ID, returns dump of incident details.
TODO: Should probably return also incident context (employee, location, ...) details
"""
if id != 0:
web.header('Content-Type', 'application/json')
return json.dumps(model.get_incident(ident=id))
prev_policies = policies_model.get_policy_history(context.user_id(),
latest=True)
# Controllers (and the server as a whole) should not know about the way data is predicted.
# Regardless how it works, the simulation should appear to the outside
# as one model that takes a policy and returns an incident
for policy in prev_policies:
policy_context = {
"employees": [policy['employee']],
"locations": [policy['location']],
"devices": [policy['device']]
}
related = sim_model().request(policy, policy_context)
most_probable = model.get_most_probable(related)
return most_probable['name']
def insert_into_tables(self, policy, date):
"""
Inserts set of policies into table
"""
if self.check_default(policy) == 0:
id_pwpolicy = 0
else:
id_pwpolicy = db.insert(
"pw_policy",
plen=policy["plen"],
psets=policy["psets"],
pdict=policy["pdict"],
phist=policy["phist"],
prenew=policy["prenew"],
pattempts=policy["pattempts"],
precovery=policy["precovery"],
)
db.insert(
"policies",
user_id=context.user_id(),
location=policy["location"],
employee=policy["employee"],
device=policy["device"],
bio_id=policy["bdata"],
pass_id=policy["pdata"],
pw_id=id_pwpolicy,
date=date,
)
def GET(self):
"""
Handles AJAX requests to get client's most recent policies.
"""
if context.user_id() == 0:
raise web.seeother(path + '/home')
check = db.select('pw_policy', where='userid=$context.user_id()', order='date DESC', vars=locals())
if len(check) > 0:
result_get = check[0]
return json.dumps(
{
'plen': result_get.plen,
'psets': result_get.psets,
'pdict': result_get.pdict,
'phist': result_get.phist,
'prenew': result_get.prenew,
'pattempts': result_get.pattempts,
'precovery': result_get.precovery,
'date': result_get.date
}
)
else:
return json.dumps(self.default_policy)
def POST(self):
web.header('Content-Type', 'application/json')
sim = simulation()
msg = {}
payload = json.loads(web.data())
data = payload['data']
pw_policy_model.update(
{
'userid': context.user_id(),
'date': payload['date']
}, data)
calendar = calendar_model.get_calendar(data, payload['newCosts'], payload['date'])
for k, value in data.iteritems():
sim.set_policy(k, value)
msg['msg1'] = [{'name': 'risk', 'value': sim.calc_risk_prob()},
{'name': 'cost', 'value': sim.calc_prod_cost()}]
msgs = []
tmp_msg = {}
tmp_msg['id'] = payload['id']
tmp_msg['data'] = data
msgs.append(tmp_msg)
my_list = ['plen', 'psets', 'pdict', 'phist', 'prenew', 'pattempts', 'precovery']
for key in my_list:
tmp_policy = pw_policy_model.get_range(data, key)
for k in tmp_policy:
msgs.append(k)
scores = score_model().multiple_score(msgs)
msg['msg2'] = scores
msg['calendar'] = calendar
return json.dumps(msg)
def insert_into_tables(self, policy, date):
"""
Inserts set of policies into table
"""
print "policy inside insert_into_tables"
print policy
if self.check_default(policy) == 0:
id_pwpolicy = 0
else:
id_pwpolicy = db.insert('pw_policy',
plen=policy['plen'],
psets=policy['psets'],
pdict=policy['pdict'],
phist=policy['phist'],
prenew=policy['prenew'],
pattempts=policy['pattempts'],
precovery=policy['precovery'])
db.insert('policies',
user_id=context.user_id(),
location=policy['location'],
employee=policy['employee'],
device=policy['device'],
bio_id=policy['bdata'],
pass_id=policy['pdata'],
pw_id=id_pwpolicy,
date=date)
def commit_policy_update(cls, policy_update, date):
"""
Takes a direct dump of the policyUpdate object in the request JSON, and iterates through the transaction
logs, committing each policyDelta into the database.
Returns None
:param policy_update:
:param date:
"""
print "parsing update policy..."
updated_policy = policies_model().parse_policy(policy_update)
print "done"
print "getting latest policy from db..."
latest_policy = policies_model().iter_to_nested_obj(
policies_model().get_policy_history(context.user_id(), True))
print latest_policy
print "done"
print "merging policies..."
merged_policy = policies_model().merge_policies(
updated_policy, latest_policy)
print "done"
print "inserting into table"
#print policies_model().nested_obj_to_list_of_dict(merged_policy)
policies_model().insert_polices(
policies_model().nested_obj_to_list_of_dict(merged_policy), date)
print "done"
def GET(self):
web.header('Content-Type', 'application/json')
if context.user_id() == 0:
return json.dumps({'success': False, 'messages': ['Unauthorized']})
journal = records(context.user_id())
client_date = journal.get_last_sync()
response = {
'date': client_date.isoformat(),
'policyAccept': False,
'eventAccept': False,
'calendar': journal.get_calendar(client_date),
'policy': policies_model.get_policies_list(context.user_id())
}
return json.dumps(response)
def GET(self):
#check if is logged in
if context.user_id() > 0:
return render.score()
#previously rendered with: context.username(),localsys.storage.session.date and scores from get_scores
else:
#if user not logged in -> redirect to login page
raise web.seeother(path + '/home')
def commit_same_policy(cls, date):
"""
Gets the latest policy set from the server and duplicates them for the specified date.
"""
print "getting latest policy from db..."
latest_policy = policies_model().iter_to_nested_obj(
policies_model().get_policy_history(context.user_id()))
print "done"
print "inserting into table"
policies_model().insert_polices(
policies_model().nested_obj_to_list_of_dict(latest_policy), date)
print "done"
def GET(self):
# get the latest risk and cost
user_id = context.user_id()
web.header('Content-Type', 'application/json')
scores = db.select('scores', where='userid=$user_id', order="date DESC", limit=2, vars=locals())
scores_result = []
for row in scores:
tmp = {}
for key, value in row.iteritems():
tmp[key] = str(value)
scores_result.append(tmp)
return json.dumps(scores_result)
def insert_into_tables(self, policy, date):
"""
Inserts set of policies into table
"""
print "policy inside insert_into_tables"
print policy
if self.check_default(policy) == 0:
id_pwpolicy = 0
else:
id_pwpolicy = db.insert('pw_policy', plen=policy['plen'], psets=policy['psets'], pdict=policy['pdict'],
phist=policy['phist'], prenew=policy['prenew'], pattempts=policy['pattempts'],
precovery=policy['precovery'])
db.insert('policies', user_id=context.user_id(), location=policy['location'],
employee=policy['employee'], device=policy['device'], bio_id=policy['bdata'],
pass_id=policy['pdata'], pw_id=id_pwpolicy, date=date)
def POST(self):
"""
Listens to POST requests for main Chronos API
"""
payload = json.loads(web.data())
web.header('Content-Type', 'application/json')
event_accept = False
policy_accept = False
client_date = date_utils.iso8601_to_date(payload.get('date', '2014-01-06'))
if context.user_id() == 0:
return json.dumps({
'success': False,
'messages': ['Unauthorized']
})
# corrected_sync_date backtracks if client submits invalid date.
corrected_sync_date = records.sync_history(context.user_id(), client_date)
policy_update = payload.get('policyUpdate')
if corrected_sync_date.day == 1:
if policy_update is None:
# Expecting a policy update, but not found.
corrected_sync_date -= timedelta(days=1)
else:
policies_model.commit_policy_update(policy_update, corrected_sync_date)
policy_accept = True
if corrected_sync_date == records.next_due_event_date(context.user_id()):
event_accept = True
if event_accept or policy_accept:
records.clear_prophecy(context.user_id(), corrected_sync_date)
# TODO get prophecy for multiple risks
#records.record_prophecy(context.user_id(), simulation().calc_risk_prob())
response = {
'date': corrected_sync_date.isoformat(),
'policyAccept': policy_accept,
'eventAccept': event_accept,
'calendar': [
records.get_calendar(context.user_id(), corrected_sync_date)
]
}
if payload.get('initPolicy', False):
response['policy'] = policies_model().get_policies_list(context.user_id())
return json.dumps(response)
def GET(self):
# get the latest risk and cost
user_id = context.user_id()
web.header('Content-Type', 'application/json')
scores = db.select('scores',
where='userid=$user_id',
order="date DESC",
limit=2,
vars=locals())
scores_result = []
for row in scores:
tmp = {}
for key, value in row.iteritems():
tmp[key] = str(value)
scores_result.append(tmp)
return json.dumps(scores_result)
def GET(self, id=0):
"""
If given ID, returns dump of incident details.
TODO: Should probably return also incident context (employee, location, ...) details
"""
if id != 0:
web.header('Content-Type', 'application/json')
return json.dumps(model.get_incident(ident=id))
prev_policies = policies_model.get_policy_history(context.user_id(), latest=True)
# Controllers (and the server as a whole) should not know about the way data is predicted.
# Regardless how it works, the simulation should appear to the outside
# as one model that takes a policy and returns an incident
for policy in prev_policies:
policy_context = {
"employees": [policy['employee']],
"locations": [policy['location']],
"devices":[policy['device']]}
related = sim_model().request(policy, policy_context)
most_probable = model.get_most_probable(related)
return most_probable['name']
def commit_same_policy(cls, date):
"""
Gets the latest policy set from the server and duplicates them for the specified date.
"""
print "getting latest policy from db..."
latest_policy = policies_model().iter_to_nested_obj(policies_model().get_policy_history(context.user_id()))
print "done"
print "inserting into table"
policies_model().insert_polices(policies_model().nested_obj_to_list_of_dict(latest_policy), date)
print "done"
def commit_policy_update(cls, policy_update, date):
"""
Takes a direct dump of the policyUpdate object in the request JSON, and iterates through the transaction
logs, committing each policyDelta into the database.
Returns None
:param policy_update:
:param date:
"""
print "parsing update policy..."
updated_policy = policies_model().parse_policy(policy_update)
print "done"
print "getting latest policy from db..."
latest_policy = policies_model().iter_to_nested_obj(policies_model().get_policy_history(context.user_id(), True))
print latest_policy
print "done"
print "merging policies..."
merged_policy = policies_model().merge_policies(updated_policy, latest_policy)
print "done"
print "inserting into table"
#print policies_model().nested_obj_to_list_of_dict(merged_policy)
policies_model().insert_polices(policies_model().nested_obj_to_list_of_dict(merged_policy), date)
print "done"
def GET(self):
if context.user_id() > 0:
return render.intro()
else:
raise web.seeother(path + '/home')
def GET(self):
if context.user_id() == 0:
raise web.seeother(path + '/home')
return render.pwpolicy_form()
def GET(self):
if context.user_id() > 0: #if a user is logged in
return render.incident()
else:
raise web.seeother(path + '/home')
def GET(self):
last_policy = policies_model.get_policy_history(context.user_id(), latest=True)
# TODO here taking only the first one. should actually handle all 27 (3x3x3) of them
last_policy = last_policy[0]
print classifier_sklearn().predict_data(last_policy)[0]
return classifier_sklearn().predict_data(last_policy)[0]
def GET(self):
web.header('Content-Type', 'application/json')
return json.dumps(score_model.get_scores(context.user_id()))
def GET(self):
journal = records(context.user_id())
result = journal.get_recent_events()
#return at most 31 latest happened events from the journal table
return json.dumps(result)
def GET(self):
return json.dumps(score_model.get_scores(context.user_id()))
def GET(self):
policy_history = policies_model.get_policy_history(context.user_id())
if policy_history:
return json.dumps(policy_history)
