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)