Exemple #1
0
def agent_profile_delete(req_dict):
    agent = req_dict['params']['agent']
    a = AgentManager(agent)
    profileId = req_dict['params']['profileId']
    a.delete_profile(profileId)

    return HttpResponse('', status=204)
Exemple #2
0
def agents_get(req_dict):
    agent = req_dict['params']['agent']
    a = AgentManager(agent)
    agent_data = a.get_person_json()
    resp = HttpResponse(agent_data, mimetype="application/json")
    resp['Content-Length'] = str(len(agent_data))
    return resp
Exemple #3
0
def agents_get(req_dict):
    agent = req_dict['params']['agent']
    a = AgentManager(agent)
    agent_data = a.get_person_json()
    resp = HttpResponse(agent_data, mimetype="application/json")
    resp['Content-Length'] = str(len(agent_data))
    return resp
Exemple #4
0
def agent_profile_put(req_dict):
    # test ETag for concurrency
    agent = req_dict['params']['agent']
    a = AgentManager(agent, create=True)
    a.put_profile(req_dict)

    return HttpResponse("", status=204)
Exemple #5
0
def agent_profile_put(req_dict):
    # test ETag for concurrency
    agent = req_dict['params']['agent']
    a = AgentManager(agent, create=True)
    a.put_profile(req_dict)

    return HttpResponse("", status=204)
Exemple #6
0
def agent_profile_delete(req_dict):
    agent = req_dict['params']['agent']
    a = AgentManager(agent)
    profileId = req_dict['params']['profileId']
    a.delete_profile(profileId)

    return HttpResponse('', status=204)
Exemple #7
0
def agent_profile_get(req_dict):
    # add ETag for concurrency
    agent = req_dict['params']['agent']
    a = AgentManager(agent)
    
    profileId = req_dict['params'].get('profileId', None) if 'params' in req_dict else None
    if profileId:
        resource = a.get_profile(profileId)
        response = HttpResponse(resource.profile.read(), content_type=resource.content_type)
        response['ETag'] = '"%s"' % resource.etag
        return response

    since = req_dict['params'].get('since', None) if 'params' in req_dict else None
    resource = a.get_profile_ids(since)
    response = HttpResponse(json.dumps([k for k in resource]), content_type="application/json")
    return response
Exemple #8
0
def agent_profile_get(req_dict):
    # add ETag for concurrency
    agent = req_dict['params']['agent']
    a = AgentManager(agent).Agent
    ap = AgentProfileManager(a)

    profileId = req_dict['params'].get('profileId',
                                       None) if 'params' in req_dict else None
    if profileId:
        resource = ap.get_profile(profileId)
        if resource.profile:
            response = HttpResponse(resource.profile.read(),
                                    content_type=resource.content_type)
        else:
            response = HttpResponse(resource.json_profile,
                                    content_type=resource.content_type)
        response['ETag'] = '"%s"' % resource.etag
        return response

    since = req_dict['params'].get('since',
                                   None) if 'params' in req_dict else None
    resource = ap.get_profile_ids(since)
    response = HttpResponse(json.dumps([k for k in resource]),
                            content_type="application/json")
    return response
Exemple #9
0
def agent_profile_put(req_dict):
    # test ETag for concurrency
    agent = req_dict['params']['agent']
    a = AgentManager(agent).Agent
    ap = AgentProfileManager(a)
    ap.put_profile(req_dict)

    return HttpResponse("", status=204)
Exemple #10
0
 def test_group_oauth_authority(self):
     ot = "Group"
     name = "auth group"
     account = json.dumps({"homePage":"http://www.adlnet.gov","name":"freakshow"})
     members = [{"name":"the agent","account":account},
                 {"name":"the user","mbox":"mailto:[email protected]"}]
     kwargs = {"objectType":ot, "name":name, "member":members}
     g = AgentManager(params=kwargs, create=True).Agent
     self.assertEquals(g.name, name)
     self.assertEquals(g.mbox, None)
     mems = g.member.values_list('name', flat=True)
     self.assertEquals(len(mems), 2)
     self.assertIn('the agent', mems)
     self.assertIn('the user', mems)
Exemple #11
0
 def test_group_from_agent_string(self):
     ot = "Group"
     name = "the group"
     mbox = "mailto:[email protected]"
     members = [{"name":"agent1","mbox":"mailto:[email protected]"},
                 {"name":"agent2","mbox":"mailto:[email protected]"}]
     kwargs = json.dumps({"objectType":ot, "name":name, "mbox":mbox,"member":members})
     g = AgentManager(params=kwargs, create=True).Agent
     self.assertEquals(g.name, name)
     self.assertEquals(g.mbox, mbox)
     mems = g.member.values_list('name', flat=True)
     self.assertEquals(len(mems), 2)
     self.assertIn('agent1', mems)
     self.assertIn('agent2', mems)
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)
Exemple #13
0
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)