public byte[] SerialiseOicResourceCore(IOicResource input, OicMessageContentType type)
{
// Arrange
var serialiser = new OicMessageSerialiser(_resolver);
return(serialiser.Serialise(input, type));
}
public OicResponse CreateOrUpdate(OicRequest request, IOicResource resource)
{
var myResource = GetResource(request.ToUri);
if (myResource == null)
{
return(OicResponseUtility.CreateMessage(OicResponseCode.NotFound, "Resource not found"));
}
if ((myResource.Interfaces & OicResourceInterface.ReadWrite) == OicResourceInterface.ReadWrite)
{
return(OicResponseUtility.CreateMessage(OicResponseCode.OperationNotAllowed, "Operation not allowed"));
}
if (resource == null)
{
return(OicResponseUtility.CreateMessage(OicResponseCode.BadRequest, "No valid OIC resource was provided"));
}
myResource.UpdateFields(resource);
return(new OicResourceResponse(_configuration, _helloResource)
{
ResposeCode = OicResponseCode.Changed
});
}
public virtual void UpdateFields(IOicResource source)
{
var coreResource = source as OicCoreResource ??
throw ExceptionUtil.CreateResourceCastException <OicCoreResource>(nameof(source));
Name = coreResource.Name ?? Name;
Id = coreResource.Id ?? Id;
}
public string JsonSerialiseObject(IOicResource input)
{
using (var stringWriter = new StringWriter())
{
var writer = new JsonTextWriter(stringWriter);
JsonSerializer.CreateDefault().Serialize(writer, input);
writer.Flush();
return(stringWriter.ToString());
}
}
public byte[] CborSerialiseObject(IOicResource input)
{
using (var stream = new MemoryStream())
{
var writer = new CborDataWriter(stream);
JsonSerializer.CreateDefault().Serialize(writer, input);
writer.Flush();
return(stream.ToArray());
}
}
public static string GetResourceTypeId(this IOicResource resource)
{
var info = resource.GetType()
.GetTypeInfo()
.GetCustomAttributes()
.FirstOrDefault(i => i is OicResourceTypeAttribute)
as OicResourceTypeAttribute;
return(info.Id);
}
public OicResponse Create(OicRequest request, IOicResource resource)
{
var oicResource = GetResourceForPath(request);
if (oicResource != null)
{
throw new NotImplementedException();
}
return(OicResponseUtility.CreateMessage(OicResponseCode.NotFound, "Not found"));
}
public OicResponse Create(OicRequest request, IOicResource resource)
{
var myResource = GetResource(request.ToUri);
if (myResource == null)
{
return(OicResponseUtility.CreateMessage(OicResponseCode.NotFound, "Resource not found"));
}
throw new NotImplementedException();
}
public MyResources(OicConfiguration configuration)
{
_configuration = configuration;
_helloResource = new OicBaseResouece <string>
{
Interfaces = OicResourceInterface.Baseline | OicResourceInterface.ReadOnly,
ResourceTypes = { "oicnet.hello" },
RelativeUri = "/hello",
Value = "Hello World"
};
}
public static OicResourceLink FromResource(IOicResource r, LinkPolicies policies = null)
{
return(new OicResourceLink
{
Href = new Uri(r.RelativeUri, UriKind.Relative),
ResourceTypes = r.ResourceTypes,
Interfaces = r.Interfaces,
// Inlucde policies if a resource requires secure channel.
// TODO: Add observable policy
Policies = policies
});
}
public OicResponse CreateOrUpdate(OicRequest request, IOicResource resource)
{
var existing = GetResourceForPath(request);
if (existing == null)
{
return(OicResponseUtility.CreateMessage(OicResponseCode.NotFound, "Not found"));
}
if (existing is OicResourceList)
{
throw new NotImplementedException();
}
((IOicResource)existing).UpdateFields(resource);
return(new OicResourceResponse(_configuration, existing)
{
ResposeCode = OicResponseCode.Changed
});
}
public async Task <IOicResource> TestRetreive(OicResponse response, IOicResource actual)
{
throw new NotImplementedException("Api changed");
// Arrange
//_mockTransport
// .Setup(t => t.SendMessageWithResponseAsync(It.IsAny<IOicEndpoint>(),
// It.Is((OicRequest r) => r.Operation == OicRequestOperation.Get)))
// .Returns(Task.FromResult(response));
//var repository = new OicRemoteResourceRepository(new OicRemoteDevice(_mockEndpoint.Object));
//// Act
//var result = await repository.RetrieveAsync(OicRequest.Create(actual.RelativeUri));
//actual = result.GetResource(_configuration);
//// Assert
//Mock.VerifyAll(_mockTransport);
//return actual;
}
public async Task Invoke(OicContext context)
{
var resourceContext = new ResourceRepositoryContext(context, _options, _resourceRepository);
if (!resourceContext.ValidatePath())
{
await _next(context);
return;
}
OicResponse result;
var request = resourceContext.GetSubRequest();
IOicResource requestResource = null;
if (request.ContentType != OicMessageContentType.None)
{
if (request.Content == null)
{
context.Response = OicResponseUtility.CreateMessage(OicResponseCode.BadRequest, "Content type provided with no content");
return;
}
var r = _oicConfiguration.Serialiser.Deserialise(request.Content, request.ContentType);
if (r is OicResourceList list)
{
// TODO: verify grabbing the first resource is okay and enumeration is not needed.
requestResource = list.First();
}
else
{
requestResource = r as IOicResource;
}
}
if (request.Operation == OicRequestOperation.Get)
{
result = await _resourceRepository.RetrieveAsync(request);
}
else if (request.Operation == OicRequestOperation.Post)
{
result = await _resourceRepository.CreateOrUpdateAsync(request, requestResource);
}
else if (request.Operation == OicRequestOperation.Put)
{
result = await _resourceRepository.CreateAsync(request, requestResource);
}
else if (request.Operation == OicRequestOperation.Delete)
{
result = await _resourceRepository.DeleteAsync(request);
}
else
{
result = OicResponseUtility.CreateMessage(OicResponseCode.BadRequest, "Bad request");
}
if (result.ResposeCode == OicResponseCode.NotFound)
{
await _next(context);
return;
}
context.Response = result;
}
public Task <OicResponse> CreateOrUpdateAsync(OicRequest request, IOicResource resource) => Task.FromResult(CreateOrUpdate(request, resource));
public virtual Task <OicResponse> CreateOrUpdateAsync(OicRequest request, IOicResource resource)
{
throw new NotSupportedException();
}
public Task <OicResponse> CreateOrUpdateAsync(OicRequest request, IOicResource resource)
{
return(_resourceRepository.CreateOrUpdateAsync(request, resource));
}
