def handle_noargs(self, *args, **options):
# delete SystemActions older than DAYS_TO_LOG_DELETE days
cutoff_time = convert_to_utc(str((datetime.utcnow() - timedelta(days=settings.DAYS_TO_LOG_DELETE)).replace(tzinfo=utc).isoformat()))
system_actions = SystemAction.objects.filter(timestamp__lt=cutoff_time)
system_actions.delete()
self.stdout.write('Successfully deleted stale SystemActions\n')
return
def complex_get(param_dict, limit, language, format, attachments):
# Tests if value is True or "true"
voidQ = Q(voided=False)
# keep track if a filter other than time or sequence is used
reffilter = False
sinceQ = Q()
if 'since' in param_dict:
sinceQ = Q(stored__gt=convert_to_utc(param_dict['since']))
untilQ = Q()
if 'until' in param_dict:
untilQ = Q(stored__lte=convert_to_utc(param_dict['until']))
# For statements/read/mine oauth scope
authQ = Q()
if 'auth' in param_dict and (param_dict['auth'] and 'statements_mine_only' in param_dict['auth']):
q_auth = param_dict['auth']['authority']
# If oauth - set authority to look for as the user
if q_auth.oauth_identifier:
authQ = Q(authority=q_auth) | Q(authority=q_auth.get_user_from_oauth_group())
# Chain all of user's oauth clients as well
else:
oauth_clients = Agent.objects.filter(member__in=[q_auth])
authQ = Q(authority=q_auth)
for client in oauth_clients:
authQ = authQ | Q(authority=client.get_user_from_oauth_group())
agentQ = Q()
if 'agent' in param_dict:
reffilter = True
agent = None
data = param_dict['agent']
related = 'related_agents' in param_dict and param_dict['related_agents']
if not type(data) is dict:
data = convert_to_dict(data)
try:
agent = AgentManager(data).Agent
if agent.objectType == "Group":
groups = []
else:
groups = agent.member.all()
agentQ = Q(actor=agent)
for g in groups:
agentQ = agentQ | Q(actor=g)
if related:
me = chain([agent], groups)
for a in me:
agentQ = agentQ | Q(object_agent=a) | Q(authority=a) \
| Q(context_instructor=a) | Q(context_team=a) \
| Q(object_substatement__actor=a) \
| Q(object_substatement__object_agent=a) \
| Q(object_substatement__context_instructor=a) \
| Q(object_substatement__context_team=a)
except IDNotFoundError:
return[]
verbQ = Q()
if 'verb' in param_dict:
reffilter = True
verbQ = Q(verb__verb_id=param_dict['verb'])
# activity
activityQ = Q()
if 'activity' in param_dict:
reffilter = True
activityQ = Q(object_activity__activity_id=param_dict['activity'])
if 'related_activities' in param_dict and param_dict['related_activities']:
activityQ = activityQ | Q(statementcontextactivity__context_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__object_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__substatementcontextactivity__context_activity__activity_id=param_dict['activity'])
registrationQ = Q()
if 'registration' in param_dict:
reffilter = True
registrationQ = Q(context_registration=param_dict['registration'])
# If want ordered by ascending
stored_param = '-stored'
if 'ascending' in param_dict and param_dict['ascending']:
stored_param = 'stored'
stmtset = Statement.objects.filter(voidQ & untilQ & sinceQ & authQ & agentQ & verbQ & activityQ & registrationQ)
# only find references when a filter other than
# since, until, or limit was used
if reffilter:
stmtset = findstmtrefs(stmtset.distinct(), sinceQ, untilQ)
# Calculate limit of stmts to return
return_limit = set_limit(limit)
# If there are more stmts than the limit, need to break it up and return more id
if stmtset.count() > return_limit:
return initial_cache_return(stmtset, stored_param, return_limit, language, format, attachments)
else:
return create_stmt_result(stmtset, stored_param, language, format)
def complex_get(req_dict):
args = {}
language = None
# Set language if one
if 'language' in req_dict:
language = req_dict['language']
user = None
if 'user' in req_dict:
user = req_dict['user']
# Parse out params into single dict-GET data not in body
try:
the_dict = req_dict['body']
if not isinstance(the_dict, dict):
the_dict = convert_to_dict(the_dict)
except KeyError:
the_dict = req_dict
# The ascending initilization statement here sometimes throws mysql warning, but needs to be here
ascending = False
# If want ordered by ascending
if 'ascending' in the_dict:
if the_dict['ascending']:
ascending = True
# Cycle through the_dict and set since and until params
for k,v in the_dict.items():
if k.lower() == 'since':
date_object = convert_to_utc(v)
args['stored__gt'] = date_object
elif k.lower() == 'until':
date_object = convert_to_utc(v)
args['stored__lte'] = date_object
# If searching by activity or actor
if 'object' in the_dict:
object_data = the_dict['object']
obj, activity = parse_incoming_object(object_data, args)
if obj and activity:
args['stmt_object__in'] = obj
elif obj and not activity:
args['stmt_object'] = obj
else:
return []
# If searching by verb
if 'verb' in the_dict:
verb_id = the_dict['verb']
verb = models.Verb.objects.filter(verb_id=verb_id)
if verb:
args['verb'] = verb
else:
return []
# If searching by registration
if 'registration' in the_dict:
uuid = str(the_dict['registration'])
cntx = models.context.objects.filter(registration=uuid)
if cntx:
args['context'] = cntx
else:
return []
# If searching by actor
if 'actor' in the_dict:
actor_data = the_dict['actor']
actor = parse_incoming_actor(actor_data)
if actor:
args['actor'] = actor
else:
return []
# If searching by instructor
if 'instructor' in the_dict:
inst_data = the_dict['instructor']
inst = parse_incoming_instructor(inst_data)
if inst:
args['context__in'] = inst
else:
return []
# there's a default of true - ALWAYS GETS SET
if not 'authoritative' in the_dict or str(the_dict['authoritative']).upper() == 'TRUE':
args['authoritative'] = True
limit = 0
# If want results limited
if 'limit' in the_dict:
limit = int(the_dict['limit'])
sparse = True
# If want sparse results
if 'sparse' in the_dict:
# If sparse input as string
if not type(the_dict['sparse']) is bool:
if the_dict['sparse'].lower() == 'false':
sparse = False
else:
sparse = the_dict['sparse']
# For statements/read/mine oauth scope
if 'statements_mine_only' in the_dict:
args['authority'] = the_dict['auth']
# Set stored param based on ascending
if ascending:
stored_param = 'stored'
else:
stored_param = '-stored'
stmt_list = retrieve_stmts_from_db(the_dict, limit, stored_param, args)
full_stmt_list = []
# For each stmt convert to our Statement class and retrieve all json
for stmt in stmt_list:
full_stmt_list.append(stmt.object_return(sparse, language))
return full_stmt_list
def complex_get(param_dict):
# tests if value is True or "true"
stmtset = models.Statement.objects.filter(voided=False)
# keep track if a filter other than time or sequence is used
reffilter = False
sinceq = None
if 'since' in param_dict:
sinceq = Q(stored__gt=convert_to_utc(param_dict['since']))
stmtset = stmtset.filter(sinceq)
untilq = None
if 'until' in param_dict:
untilq = Q(stored__lte=convert_to_utc(param_dict['until']))
stmtset = stmtset.filter(untilq)
# For statements/read/mine oauth scope
if 'auth' in param_dict and (param_dict['auth'] and 'statements_mine_only' in param_dict['auth']):
stmtset = stmtset.filter(authority=param_dict['auth']['id'])
agentQ = Q()
if 'agent' in param_dict:
reffilter = True
agent = None
data = param_dict['agent']
related = 'related_agents' in param_dict and param_dict['related_agents']
if not type(data) is dict:
data = convert_to_dict(data)
try:
agent = AgentManager(data).Agent
if agent.objectType == "Group":
groups = []
else:
groups = agent.member.all()
agentQ = Q(actor=agent)
for g in groups:
agentQ = agentQ | Q(actor=g)
if related:
me = chain([agent], groups)
for a in me:
agentQ = agentQ | Q(object_agent=a) | Q(authority=a) \
| Q(context_instructor=a) | Q(context_team=a) \
| Q(object_substatement__actor=a) \
| Q(object_substatement__object_agent=a) \
| Q(object_substatement__context_instructor=a) \
| Q(object_substatement__context_team=a)
except models.IDNotFoundError:
return[]
verbQ = Q()
if 'verb' in param_dict:
reffilter = True
verbQ = Q(verb__verb_id=param_dict['verb'])
# activity
activityQ = Q()
if 'activity' in param_dict:
reffilter = True
activityQ = Q(object_activity__activity_id=param_dict['activity'])
if 'related_activities' in param_dict and param_dict['related_activities']:
activityQ = activityQ | Q(statementcontextactivity__context_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__object_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__substatementcontextactivity__context_activity__activity_id=param_dict['activity'])
registrationQ = Q()
if 'registration' in param_dict:
reffilter = True
registrationQ = Q(context_registration=param_dict['registration'])
# If want ordered by ascending
stored_param = '-stored'
if 'ascending' in param_dict and param_dict['ascending']:
stored_param = 'stored'
stmtset = stmtset.filter(agentQ & verbQ & activityQ & registrationQ)
# only find references when a filter other than
# since, until, or limit was used
if reffilter:
stmtset = findstmtrefs(stmtset.distinct(), sinceq, untilq)
return stmtset.order_by(stored_param)
def complex_get(req_dict):
# tests if value is True or "true"
stmtset = models.Statement.objects.filter(voided=False)
# keep track if a filter other than time or sequence is used
reffilter = False
# Parse out params into single dict-GET data not in body
the_dict={}
try:
the_dict = req_dict['body']
if not isinstance(the_dict, dict):
the_dict = convert_to_dict(the_dict)
except KeyError:
pass # no params in the body
the_dict.update(req_dict['params'])
sinceq = None
if 'since' in the_dict:
sinceq = Q(stored__gt=convert_to_utc(the_dict['since']))
stmtset = stmtset.filter(sinceq)
untilq = None
if 'until' in the_dict:
untilq = Q(stored__lte=convert_to_utc(the_dict['until']))
stmtset = stmtset.filter(untilq)
# For statements/read/mine oauth scope
if 'auth' in req_dict and (req_dict['auth'] and 'statements_mine_only' in req_dict['auth']):
stmtset = stmtset.filter(authority=req_dict['auth']['id'])
agentQ = Q()
if 'agent' in the_dict:
reffilter = True
agent = None
data = the_dict['agent']
related = 'related_agents' in the_dict and the_dict['related_agents']
if not type(data) is dict:
data = convert_to_dict(data)
try:
agent = AgentManager(data).Agent
if agent.objectType == "Group":
groups = []
else:
groups = agent.member.all()
agentQ = Q(actor=agent)
for g in groups:
agentQ = agentQ | Q(actor=g)
if related:
me = chain([agent], groups)
for a in me:
agentQ = agentQ | Q(stmt_object=a) | Q(authority=a) \
| Q(context__instructor=a) | Q(context__team=a) \
| Q(stmt_object__substatement__actor=a) \
| Q(stmt_object__substatement__stmt_object=a) \
| Q(stmt_object__substatement__context__instructor=a) \
| Q(stmt_object__substatement__context__team=a)
except models.IDNotFoundError:
return[]
verbQ = Q()
if 'verb' in the_dict:
reffilter = True
verbQ = Q(verb__verb_id=the_dict['verb'])
# activity
activityQ = Q()
if 'activity' in the_dict:
reffilter = True
activityQ = Q(stmt_object__activity__activity_id=the_dict['activity'])
if 'related_activities' in the_dict and the_dict['related_activities']:
activityQ = activityQ | Q(context__contextactivity__context_activity__activity_id=the_dict['activity']) \
| Q(stmt_object__substatement__stmt_object__activity__activity_id=the_dict['activity']) \
| Q(stmt_object__substatement__context__contextactivity__context_activity__activity_id=the_dict['activity'])
registrationQ = Q()
if 'registration' in the_dict:
reffilter = True
registrationQ = Q(context__registration=the_dict['registration'])
format = the_dict['format']
# Set language if one
# pull from req_dict since language is from a header, not an arg
language = None
if 'headers' in req_dict and ('format' in the_dict and the_dict['format'] == "canonical"):
if 'language' in req_dict['headers']:
language = req_dict['headers']['language']
else:
language = settings.LANGUAGE_CODE
# If want ordered by ascending
stored_param = '-stored'
if 'ascending' in the_dict and the_dict['ascending']:
stored_param = 'stored'
stmtset = stmtset.filter(agentQ & verbQ & activityQ & registrationQ)
# only find references when a filter other than
# since, until, or limit was used
if reffilter:
stmtset = findstmtrefs(stmtset.distinct(), sinceq, untilq)
stmt_list = stmtset.order_by(stored_param)
# For each stmt retrieve all json
full_stmt_list = []
full_stmt_list = [stmt.object_return(language, format) for stmt in stmt_list]
return full_stmt_list
def complex_get(param_dict):
# tests if value is True or "true"
stmtset = models.Statement.objects.filter(voided=False)
# keep track if a filter other than time or sequence is used
reffilter = False
sinceq = None
if 'since' in param_dict:
sinceq = Q(stored__gt=convert_to_utc(param_dict['since']))
stmtset = stmtset.filter(sinceq)
untilq = None
if 'until' in param_dict:
untilq = Q(stored__lte=convert_to_utc(param_dict['until']))
stmtset = stmtset.filter(untilq)
# For statements/read/mine oauth scope
if 'auth' in param_dict and (param_dict['auth'] and 'statements_mine_only'
in param_dict['auth']):
stmtset = stmtset.filter(authority=param_dict['auth']['id'])
agentQ = Q()
if 'agent' in param_dict:
reffilter = True
agent = None
data = param_dict['agent']
related = 'related_agents' in param_dict and param_dict[
'related_agents']
if not type(data) is dict:
data = convert_to_dict(data)
try:
agent = AgentManager(data).Agent
if agent.objectType == "Group":
groups = []
else:
groups = agent.member.all()
agentQ = Q(actor=agent)
for g in groups:
agentQ = agentQ | Q(actor=g)
if related:
me = chain([agent], groups)
for a in me:
agentQ = agentQ | Q(object_agent=a) | Q(authority=a) \
| Q(context_instructor=a) | Q(context_team=a) \
| Q(object_substatement__actor=a) \
| Q(object_substatement__object_agent=a) \
| Q(object_substatement__context_instructor=a) \
| Q(object_substatement__context_team=a)
except models.IDNotFoundError:
return []
verbQ = Q()
if 'verb' in param_dict:
reffilter = True
verbQ = Q(verb__verb_id=param_dict['verb'])
# activity
activityQ = Q()
if 'activity' in param_dict:
reffilter = True
activityQ = Q(object_activity__activity_id=param_dict['activity'])
if 'related_activities' in param_dict and param_dict[
'related_activities']:
activityQ = activityQ | Q(statementcontextactivity__context_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__object_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__substatementcontextactivity__context_activity__activity_id=param_dict['activity'])
registrationQ = Q()
if 'registration' in param_dict:
reffilter = True
registrationQ = Q(context_registration=param_dict['registration'])
# If want ordered by ascending
stored_param = '-stored'
if 'ascending' in param_dict and param_dict['ascending']:
stored_param = 'stored'
stmtset = stmtset.filter(agentQ & verbQ & activityQ & registrationQ)
# only find references when a filter other than
# since, until, or limit was used
if reffilter:
stmtset = findstmtrefs(stmtset.distinct(), sinceq, untilq)
return stmtset.order_by(stored_param)
def complex_get(param_dict, limit, language, format, attachments):
# Tests if value is True or "true"
vq = Q(voided=False)
# keep track if a filter other than time or sequence is used
reffilter = False
sinceq = Q()
if 'since' in param_dict:
sinceq = Q(stored__gt=convert_to_utc(param_dict['since']))
untilq = Q()
if 'until' in param_dict:
untilq = Q(stored__lte=convert_to_utc(param_dict['until']))
# For statements/read/mine oauth scope
authq = Q()
if 'auth' in param_dict and (param_dict['auth'] and 'statements_mine_only'
in param_dict['auth']):
authq = Q(authority=param_dict['auth']['id'])
agentQ = Q()
if 'agent' in param_dict:
reffilter = True
agent = None
data = param_dict['agent']
related = 'related_agents' in param_dict and param_dict[
'related_agents']
if not type(data) is dict:
data = convert_to_dict(data)
try:
agent = AgentManager(data).Agent
if agent.objectType == "Group":
groups = []
else:
groups = agent.member.all()
agentQ = Q(actor=agent)
for g in groups:
agentQ = agentQ | Q(actor=g)
if related:
me = chain([agent], groups)
for a in me:
agentQ = agentQ | Q(object_agent=a) | Q(authority=a) \
| Q(context_instructor=a) | Q(context_team=a) \
| Q(object_substatement__actor=a) \
| Q(object_substatement__object_agent=a) \
| Q(object_substatement__context_instructor=a) \
| Q(object_substatement__context_team=a)
except IDNotFoundError:
return []
verbQ = Q()
if 'verb' in param_dict:
reffilter = True
verbQ = Q(verb__verb_id=param_dict['verb'])
# activity
activityQ = Q()
if 'activity' in param_dict:
reffilter = True
activityQ = Q(object_activity__activity_id=param_dict['activity'])
if 'related_activities' in param_dict and param_dict[
'related_activities']:
activityQ = activityQ | Q(statementcontextactivity__context_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__object_activity__activity_id=param_dict['activity']) \
| Q(object_substatement__substatementcontextactivity__context_activity__activity_id=param_dict['activity'])
registrationQ = Q()
if 'registration' in param_dict:
reffilter = True
registrationQ = Q(context_registration=param_dict['registration'])
# If want ordered by ascending
stored_param = '-stored'
if 'ascending' in param_dict and param_dict['ascending']:
stored_param = 'stored'
stmtset = Statement.objects.filter(vq & untilq & sinceq & authq & agentQ
& verbQ & activityQ & registrationQ)
# only find references when a filter other than
# since, until, or limit was used
if reffilter:
stmtset = findstmtrefs(stmtset.distinct(), sinceq, untilq)
# Calculate limit of stmts to return
return_limit = set_limit(limit)
# If there are more stmts than the limit, need to break it up and return more id
if stmtset.count() > return_limit:
return initial_cache_return(stmtset, stored_param, return_limit,
language, format, attachments)
else:
return create_stmt_result(stmtset, stored_param, language, format)
