def retrieve(self, cseid, ft):
if cseid not in self._db.list_collection_names():
raise KeyError
result = self._db[cseid].find_one(ft)
if result is None:
return None
elif 'ty' in result:
resource = ResourcesFactory().create(ty=result['ty'])
resource.load(pc={resource.get_rtn(): result})
rtn = None
if 'rtn' in result:
rtn = result['rtn']
result.pop('rtn')
else:
raise KeyError
_id = None
if '_id' in result:
_id = result['_id']
result.pop('_id')
else:
raise KeyError
resource.load({rtn: result})
resource.set_id(str(_id))
return resource
else:
raise TypeError
def test_module_create_cnt(self):
f = ResourcesFactory()
# create CSE
csebase = f.create(ResourceType.CSEBase.value)
csebase.set_csi(settings.GHOSTM2M['CSE-ID'])
csebase_ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'],
csebase)
# create parent AE
ae = f.create(ty=ResourceType.AE.value,
pi=csebase_ri,
pc={'m2m:ae': {
'api': 'test',
'apn': 'rfid-reader'
}})
ae_mapper = MappersFactory().get(ae)
ae_ri = ae_mapper.store(settings.GHOSTM2M['CSE-ID'], ae)
# create Container
cnt = f.create(ty=ResourceType.container.value,
pi=ae_ri,
pc={'m2m:cnt': {
'rn': 'corner-rfids'
}})
cnt_mapper = MappersFactory().get(cnt)
cnt_ri = cnt_mapper.store(settings.GHOSTM2M['CSE-ID'], cnt)
cnt.set_id(cnt_ri)
recorded_cnt = cnt_mapper.retrieve(settings.GHOSTM2M['CSE-ID'],
{'_id': ObjectId(cnt_ri)})
# test dict
self.assertIn('m2m:cnt', cnt.resource)
self.assertIn('pi', cnt.resource['m2m:cnt'])
self.assertIn('rn', cnt.resource['m2m:cnt'])
self.assertEqual(ae_ri, cnt.resource['m2m:cnt']['pi'])
self.assertEqual('corner-rfids', cnt.resource['m2m:cnt']['rn'])
# test module
self.assertEqual(cnt.rn, 'corner-rfids')
self.assertEqual(cnt.pi, ae_ri)
self.assertEqual(cnt.ri, cnt_ri)
# test db
self.assertIsInstance(recorded_cnt, Container)
self.assertEqual(recorded_cnt.rn, 'corner-rfids')
self.assertEqual(recorded_cnt.pi, ae_ri)
def run():
"""
create a CSEBase
"""
resource = ResourcesFactory().create(ResourceType.CSEBase.value)
resource.set_csi(settings.GHOSTM2M['CSE-ID'])
base = DBConnection().db[settings.GHOSTM2M['CSE-ID']]
result = base.find_one({
'ty': ResourceType.CSEBase.value,
'csi': settings.GHOSTM2M['CSE-ID']
})
if result is None:
ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'], resource)
print('Creado CSEBase. ', ri)
else:
print('CSEBase ya existe. ', result)
def run():
"""
reset db
"""
try:
DBConnection().db_client.drop_database(settings.GHOSTM2M["dbname"])
DBConnection().db_client.drop_database('users')
print('OK')
except Exception as e:
print(str(e))
# create CSEBase
resource = ResourcesFactory().create(ResourceType.CSEBase.value)
resource.set_csi(settings.GHOSTM2M['CSE-ID'])
base = DBConnection().db[settings.GHOSTM2M['CSE-ID']]
result = base.find_one({
'ty': ResourceType.CSEBase.value,
'csi': settings.GHOSTM2M['CSE-ID']
})
if result is None:
ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'], resource)
print('Creado CSEBase. ', ri)
else:
print('CSEBase ya existe. ', result)
# create user admin
try:
users = DBConnection().db['users']
result = users.insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
print("se crea usuario admin")
except Exception as e:
print('no se crea usuario admin')
print(str(e))
def test_module_create_ae(self):
f = ResourcesFactory()
# create CSE
csebase = f.create(ResourceType.CSEBase.value)
csebase.set_csi(settings.GHOSTM2M['CSE-ID'])
csebase_ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'],
csebase)
# create AE
ae = f.create(ty=ResourceType.AE.value,
pi=csebase_ri,
pc={'m2m:ae': {
'api': 'test',
'apn': 'rfid-reader'
}})
ae_mapper = MappersFactory().get(ae)
ae_ri = ae_mapper.store(settings.GHOSTM2M['CSE-ID'], ae)
# test dict
self.assertIn('m2m:ae', ae.resource)
self.assertIn('pi', ae.resource['m2m:ae'])
self.assertEqual(csebase_ri, ae.resource['m2m:ae']['pi'])
# test module
self.assertEqual(ae.apn, 'rfid-reader')
self.assertEqual(ae.api, 'test')
self.assertEqual(ae.pi, csebase_ri)
recorded_ae = ae_mapper.retrieve(settings.GHOSTM2M['CSE-ID'],
{'_id': ObjectId(ae_ri)})
self.assertIsInstance(recorded_ae, AE)
self.assertEqual(recorded_ae.apn, 'rfid-reader')
self.assertEqual(recorded_ae.api, 'test')
self.assertEqual(recorded_ae.pi, csebase_ri)
def m2mrequest(request, cseid, resourceid=None, attrib=None):
data = json.loads(request.body)
primitive = None
# parse URL
try:
http_to = dict()
http_to['cse-id'] = cseid
if resourceid is not None:
http_to['unstructured-resource-id'] = resourceid
if attrib is not None:
http_to['attr'] = attrib
except:
resp = ResponsePrimitive(
0, ResponseStatusCode.INTERNAL_SERVER_ERROR.value)
return JsonResponse(resp.toDict())
try:
if 'm2m:rqp' in data:
primitive = data['m2m:rqp']
except KeyError:
resp = ResponsePrimitive(0, ResponseStatusCode.BAD_REQUEST.value)
return JsonResponse(resp.toDict())
try:
if 'fr' in primitive:
fr = primitive['fr']
username, pwd = fr.split(':', maxsplit=2)
user = User(username, pwd)
if not user.valid():
resp = ResponsePrimitive(
0, ResponseStatusCode.OPERATION_NOT_ALLOWED.value)
return JsonResponse(resp.toDict())
except Exception:
resp = ResponsePrimitive(0, ResponseStatusCode.BAD_REQUEST.value)
return JsonResponse(resp.toDict())
# CREATE or NOTIFY
if request.method == "POST":
try:
if 'op' in primitive:
op = primitive['op']
except KeyError:
return JsonResponse({
'status': 0,
'info': 'no operation in primitive'
})
try:
if 'ty' in primitive:
ty = primitive['ty']
except KeyError:
return JsonResponse({
'status': 0,
'info': 'no resourceType in request primitive'
})
if op == Operation.Create.value:
resource = None
try:
if primitive['ty'] == ResourceType.AE.value:
target_resource = http_to['cse-id']
else:
target_resource = http_to['unstructured-resource-id']
if target_resource is None:
resp = ResponsePrimitive(
rsc=ResponseStatusCode.BAD_REQUEST.value)
return JsonResponse(resp.toDict())
pc = None
if 'pc' in primitive:
pc = primitive['pc']
resource = ResourcesFactory().create(ty=primitive['ty'],
pc=pc,
pi=target_resource)
mapper = MappersFactory().get(resource)
ri = mapper.store(http_to['cse-id'], resource)
resource.set_id(ri)
resp = ResponsePrimitive(rsc=ResponseStatusCode.CREATED.value)
resp.set_pc(resource.toDict())
return JsonResponse(resp.toDict())
except:
resp = ResponsePrimitive(
rsc=ResponseStatusCode.BAD_REQUEST.value)
return JsonResponse(resp.toDict())
else:
resp = ResponsePrimitive(
rsc=ResponseStatusCode.NOT_IMPLEMENTED.value)
return JsonResponse(resp.toDict())
# RETRIEVE or DISCOVERY
elif request.method == "GET":
try:
try:
if 'op' in primitive:
op = primitive['op']
except KeyError:
rsp = ResponsePrimitive(
rsc=ResponseStatusCode.BAD_REQUEST.value)
return JsonResponse(rsp.toDict())
if op == Operation.Retrieve.value:
if 'unstructured-resource-id' in http_to:
resource = ResourceMapper().retrieve(
http_to["cse-id"],
{'_id': ObjectId(http_to['unstructured-resource-id'])})
else:
resource = ResourceMapper().retrieve(
http_to["cse-id"], {'csi': http_to['cse-id']})
filter_criteria = request.GET.dict()
if filter_criteria:
# DISCOVERY
results = ResourceMapper().discovery(
http_to["cse-id"], http_to['unstructured-resource-id'],
filter_criteria)
rsp = {
"m2m:rsp": {
"pc": {
"m2m:uril": results
},
"rsc": ResponseStatusCode.OK.value,
"ri": resource.get_id()
}
}
return JsonResponse(rsp)
if 'attr' in http_to:
if hasattr(resource, http_to['attr']):
target_attr = getattr(resource, http_to['attr'])
rsp = ResponsePrimitive(
rsc=ResponseStatusCode.OK.value)
rsp.set_pc(target_attr)
return JsonResponse(rsp.toDict())
else:
rsp = ResponsePrimitive(
rsc=ResponseStatusCode.NOT_FOUND.value)
return JsonResponse(rsp.toDict())
else:
if resource is None:
rsp = ResponsePrimitive(
rsc=ResponseStatusCode.NOT_FOUND.value)
return JsonResponse(rsp.toDict())
rsp = ResponsePrimitive(rsc=ResponseStatusCode.OK.value)
rsp.set_pc(resource.toDict())
return JsonResponse(rsp.toDict())
else:
rsp = ResponsePrimitive(
rsc=ResponseStatusCode.NOT_IMPLEMENTED.value)
return JsonResponse(rsp.toDict())
except Exception:
rsp = ResponsePrimitive(
rsc=ResponseStatusCode.INTERNAL_SERVER_ERROR.value)
return JsonResponse(rsp.toDict())
else:
rsp = ResponsePrimitive(rsc=ResponseStatusCode.NOT_IMPLEMENTED.value)
return JsonResponse(rsp.toDict())
def test_api_retrieve(self):
f = ResourcesFactory()
# create admin user
result = DBConnection().db['users'].find_one(
{'_id': settings.GHOSTM2M['admin-user']['username']})
if result is None:
DBConnection().db['users'].insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
# create CSE
csebase = f.create(ResourceType.CSEBase.value)
csebase.set_csi(settings.GHOSTM2M['CSE-ID'])
csebase_ri = CSEBaseMapper().store(settings.GHOSTM2M['CSE-ID'],
csebase)
# create AE
ae = f.create(ty=ResourceType.AE.value,
pi=csebase_ri,
pc={'m2m:ae': {
'api': 'test',
'apn': 'rfid-reader'
}})
ae_mapper = MappersFactory().get(ae)
ae_ri = ae_mapper.store(settings.GHOSTM2M['CSE-ID'], ae)
ae.set_id(ae_ri)
# create Container
cnt = f.create(ty=ResourceType.container.value,
pi=ae_ri,
pc={'m2m:cnt': {
'rn': 'corner-rfids'
}})
cnt_mapper = MappersFactory().get(cnt)
cnt_ri = cnt_mapper.store(settings.GHOSTM2M['CSE-ID'], cnt)
cnt.set_id(cnt_ri)
# create ContentInstance
cin = f.create(ty=ResourceType.contentInstance.value,
pi=cnt_ri,
pc={'m2m:cin': {
'con': 'abcdef'
}})
cin_mapper = MappersFactory().get(cin)
cin_ri = cin_mapper.store(settings.GHOSTM2M['CSE-ID'], cin)
cin.set_id(cin_ri)
# Request CSE
#
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo', request_str,
'application/json')
self.assertEqual(response.status_code, 200)
response_cse = json.loads(response.content)['m2m:rsp']
self.assertIn('rsc', response_cse)
self.assertEqual(response_cse['rsc'], ResponseStatusCode.OK.value)
# Request AE
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(ae_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_ae = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_ae)
self.assertIn('m2m:ae', response_ae['pc'])
self.assertIn('apn', response_ae['pc']['m2m:ae'])
self.assertIn('ri', response_ae['pc']['m2m:ae'])
# Request Container
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cnt)
self.assertIn('m2m:cnt', response_cnt['pc'])
self.assertIn('rn', response_cnt['pc']['m2m:cnt'])
self.assertIn('ri', response_cnt['pc']['m2m:cnt'])
self.assertIn('cni', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['cni'], 1)
# Request ContentInstance
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cin_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cin = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cin)
self.assertIn('m2m:cin', response_cin['pc'])
self.assertIn('con', response_cin['pc']['m2m:cin'])
self.assertIn('ri', response_cin['pc']['m2m:cin'])
self.assertIn('pi', response_cin['pc']['m2m:cin'])
self.assertEqual(response_cin['pc']['m2m:cin']['pi'], cnt_ri)
# Request <last> <ContentInstance>
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET',
'/~/Cernicalo/{}/la'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_la = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cin)
# Check updated parent <Container>
request = {
'm2m:rqp': {
'op':
Operation.Retrieve.value,
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo',
}
}
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_cnt)
self.assertIn('m2m:cnt', response_cnt['pc'])
self.assertIn('rn', response_cnt['pc']['m2m:cnt'])
self.assertIn('ri', response_cnt['pc']['m2m:cnt'])
self.assertIn('la', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['la'], cin_ri)
# create another ContentInstance
cin = f.create(ty=ResourceType.contentInstance.value,
pi=cnt_ri,
pc={'m2m:cin': {
'con': 'segundocontent'
}})
cin_mapper = MappersFactory().get(cin)
cin_ri = cin_mapper.store(settings.GHOSTM2M['CSE-ID'], cin)
cin.set_id(cin_ri)
request_str = json.dumps(request)
response = self.client.generic('GET', '/~/Cernicalo/{}'.format(cnt_ri),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
self.assertIn('cni', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['cni'], 2)
self.assertIn('la', response_cnt['pc']['m2m:cnt'])
self.assertEqual(response_cnt['pc']['m2m:cnt']['la'], cin_ri)
request_str = json.dumps(request)
response = self.client.generic(
'GET',
'/~/Cernicalo/{}?ty={}'.format(cnt_ri,
ResourceType.contentInstance.value),
request_str, 'application/json')
self.assertEqual(response.status_code, 200)
self.assertIn('m2m:rsp', json.loads(response.content))
response_discovery = json.loads(response.content)['m2m:rsp']
self.assertIn('pc', response_discovery)
self.assertIn('m2m:uril', response_discovery['pc'])
self.assertIsInstance(response_discovery['pc']['m2m:uril'], list)
def test_api_create_cin(self):
# create admin user
result = DBConnection().db['users'].find_one(
{'_id': settings.GHOSTM2M['admin-user']['username']})
if result is None:
DBConnection().db['users'].insert_one({
'_id':
settings.GHOSTM2M['admin-user']['username'],
'pwd':
settings.GHOSTM2M['admin-user']['pwd']
})
# send request for create AE
request = {
'm2m:rqp': {
'op':
1,
'ty':
1,
'pc': {
'm2m:ae': {
"apn": "lector-tarjetas"
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'//localhost:80/Cernicalo'
}
}
response = self.client.post('/~/Cernicalo/',
json.dumps(request),
content_type="application/json")
self.assertEqual(response.status_code, 200)
response_ae = json.loads(response.content)['m2m:rsp']
factory = ResourcesFactory()
parent_ae = factory.create(request['m2m:rqp']['ty'],
pc=response_ae['pc'])
request = {
'm2m:rqp': {
'op':
Operation.Create.value,
'ty':
ResourceType.container.value,
'pc': {
'm2m:cnt': {
'rn': 'corners-rfids'
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo/{}'.format(parent_ae.ri),
}
}
response = self.client.post('/~/Cernicalo/{}'.format(parent_ae.ri),
json.dumps(request),
content_type="application/json")
self.assertEqual(response.status_code, 200)
response_cnt = json.loads(response.content)['m2m:rsp']
cnt = factory.create(request['m2m:rqp']['ty'], pc=response_cnt['pc'])
request = {
'm2m:rqp': {
'op':
Operation.Create.value,
'ty':
ResourceType.contentInstance.value,
'pc': {
'm2m:cin': {
'con': 'hola mundo!'
}
},
'fr':
'{}:{}'.format(settings.GHOSTM2M['admin-user']['username'],
settings.GHOSTM2M['admin-user']['pwd']),
'to':
'/~/Cernicalo/{}'.format(cnt.ri),
}
}
response = self.client.post('/~/Cernicalo/{}'.format(cnt.ri),
json.dumps(request),
content_type="application/json")
self.assertIn('m2m:rsp', json.loads(response.content))
response_cin = json.loads(response.content)['m2m:rsp']
self.assertIn('m2m:cin', response_cin['pc'])
cin = factory.create(request['m2m:rqp']['ty'], pc=response_cin['pc'])
self.assertIsInstance(cin, ContentInstance)
self.assertEqual(cin.pi, cnt.ri)
self.assertEqual(cin.con, 'hola mundo!')
parent = ResourceMapper().retrieve(cseid=settings.GHOSTM2M['CSE-ID'],
ft={'_id': ObjectId(cin.pi)})
self.assertIsInstance(parent, Container)
self.assertNotEqual(parent.la, None)