private void Channel_OnOpen(object sender, ChannelOpenEventArgs e)
{
if (!Channel.IsAuthenticated)
{
OnError?.Invoke(this,
new ProtocolAdapterErrorEventArgs(Channel.Id,
new SecurityException("Not authenticated on WSN channel")));
Channel.CloseAsync().Ignore();
return;
}
adapter = new OrleansAdapter(identity, "WebSocket", "WSN", graphManager);
adapter.OnObserve += Adapter_OnObserve;
if (subscriptions != null)
{
foreach (var sub in subscriptions)
{
SubscriptionMetadata metadata = new SubscriptionMetadata
{
Identity = identity,
Indexes = localIndexes,
IsEphemeral = true
};
adapter.SubscribeAsync(resource, metadata).GetAwaiter();
}
}
}
public RedisSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
tqueue = new TaskQueue();
cqm = new ConcurrentQueueManager();
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
connectionString = $"{uri.Authority}:6380,password={metadata.SymmetricKey},ssl=True,abortConnect=False";
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
if (!int.TryParse(nvc["db"], out dbNumber))
{
dbNumber = -1;
}
if (TimeSpan.TryParse(nvc["expiry"], out TimeSpan expiration))
{
expiry = expiration;
}
if (string.IsNullOrEmpty(metadata.ClaimKey))
{
cacheClaimType = metadata.ClaimKey;
}
connection = ConnectionMultiplexer.ConnectAsync(connectionString).GetAwaiter().GetResult();
database = connection.GetDatabase(dbNumber);
}
public async Task <CoapMessage> PutAsync(CoapMessage message)
{
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
//EventValidator.Validate(false, resourceUriString, Channel, graphManager, context).Validated
//if (!await adapter.CanSubscribeAsync(uri.Resource, channel.IsEncrypted))
if (EventValidator.Validate(false, uri.Resource, channel, graphManager).Validated)
{
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (coapObserved.ContainsKey(uri.Resource) || coapUnobserved.Contains(uri.Resource))
{
//resource previously subscribed
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.NotAcceptable, message.Token));
}
//this point the resource is not being observed, so we can
// #1 subscribe to it
// #2 add to unobserved resources (means not coap observed)
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
coapUnobserved.Add(uri.Resource);
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Created, message.Token));
}
public EventGridSink(SubscriptionMetadata metadata)
: base(metadata)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
topicHostname = uri.Authority;
topicKey = metadata.SymmetricKey;
string uriString = new Uri(metadata.SubscriptionUriString).ToString();
resourceUriString = uriString.Replace("/" + uri.Segments[uri.Segments.Length - 1], "");
if (!int.TryParse(nvc["clients"], out clientCount))
{
clientCount = 1;
}
ServiceClientCredentials credentials = new TopicCredentials(topicKey);
clients = new EventGridClient[clientCount];
for (int i = 0; i < clientCount; i++)
{
clients[i] = new EventGridClient(credentials);
}
}
public AzureQueueStorageSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
loadQueue = new ConcurrentQueue <EventMessage>();
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
queue = nvc["queue"];
string ttlString = nvc["ttl"];
if (!string.IsNullOrEmpty(ttlString))
{
ttl = TimeSpan.Parse(ttlString);
}
Uri.TryCreate(metadata.SymmetricKey, UriKind.Absolute, out Uri sasUri);
if (sasUri == null)
{
storage = QueueStorage.New(
$"DefaultEndpointsProtocol=https;AccountName={uri.Authority.Split(new[] { '.' })[0]};AccountKey={metadata.SymmetricKey};",
10000, 1000);
}
else
{
string connectionString = $"BlobEndpoint={queue};SharedAccessSignature={metadata.SymmetricKey}";
storage = QueueStorage.New(connectionString, 1000, 5120000);
}
}
public async Task <string> SubscribeAsync(string resourceUriString, SubscriptionMetadata metadata)
{
metadata.IsEphemeral = true;
string subscriptionUriString = await GraphManager.SubscribeAsync(resourceUriString, metadata);
//create and observer and wire up event to receive notifications
MessageObserver observer = new MessageObserver();
observer.OnNotify += Observer_OnNotify;
//set the observer in the subscription with the lease lifetime
TimeSpan leaseTime = TimeSpan.FromSeconds(20.0);
string leaseKey = await GraphManager.AddSubscriptionObserverAsync(subscriptionUriString, leaseTime, observer);
//add the lease key to the list of ephemeral observers
ephemeralObservers.Add(subscriptionUriString, observer);
//add the resource, subscription, and lease key the container
if (!container.ContainsKey(resourceUriString))
{
container.Add(resourceUriString, new Tuple <string, string>(subscriptionUriString, leaseKey));
}
//ensure the lease timer is running
EnsureLeaseTimer();
return(subscriptionUriString);
}
protected override void ProcessRecord()
{
string uriString;
if (string.IsNullOrEmpty(Filename))
{
uriString = string.Format("https://{0}.blob.core.windows.net?container={1}&blobtype={2}&clients={3}",
Account, Container, BlobType.ToString(), NumClients <= 0 ? 1 : NumClients);
}
else
{
uriString = string.Format(
"https://{0}.blob.core.windows.net?container={1}&blobtype={2}&clients={3}&file={4}", Account,
Container, BlobType.ToString(), NumClients <= 0 ? 1 : NumClients, Filename);
}
SubscriptionMetadata metadata = new SubscriptionMetadata
{
IsEphemeral = false,
NotifyAddress = uriString,
SymmetricKey = Key,
Description = Description
};
string url = string.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl,
ResourceUriString);
RestRequestBuilder builder =
new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
protected override void ProcessRecord()
{
string uriString = string.Format("iothub://{0}.azure-devices.net?deviceid={1}", Account, DeviceId);
if (!string.IsNullOrEmpty(PropertyName))
{
uriString = string.Format("{0}&propname={1}&propvalue={1}", uriString, PropertyName, PropertyValue);
}
SubscriptionMetadata metadata = new SubscriptionMetadata
{
IsEphemeral = false,
NotifyAddress = uriString,
SymmetricKey = Key,
Description = Description
};
string url = string.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl,
ResourceUriString);
RestRequestBuilder builder =
new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
protected override void ProcessRecord()
{
string uriString = WebServiceUrl;
Uri uri = new Uri(uriString);
string query = !String.IsNullOrEmpty(Issuer) && !String.IsNullOrEmpty(Audience) ? String.Format("issuer={0}&audience={1}", Issuer, Audience) :
!String.IsNullOrEmpty(Issuer) ? String.Format("issuer={0}", Issuer) :
!String.IsNullOrEmpty(Audience) ? String.Format("audience={0}", Audience) : null;
uriString = !String.IsNullOrEmpty(uri.Query) && !String.IsNullOrEmpty(query) ? String.Format("&{0}&{1}", uriString, query) :
String.IsNullOrEmpty(uri.Query) && !String.IsNullOrEmpty(query) ? String.Format("?{0}&{1}", uriString, query) :
uriString;
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = false,
NotifyAddress = uriString,
SymmetricKey = Key,
TokenType = this.TokenType,
Description = this.Description
};
string url = String.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl, ResourceUriString);
RestRequestBuilder builder = new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
protected override void ProcessRecord()
{
string uriString = TTL.HasValue
? string.Format("https://{0}.queue.core.windows.net?queue={1}&ttl={2}", Account, Queue,
TTL.Value.ToString())
: string.Format("https://{0}.queue.core.windows.net?queue={1}", Account, Queue);
SubscriptionMetadata metadata = new SubscriptionMetadata
{
IsEphemeral = false,
NotifyAddress = uriString,
SymmetricKey = Key,
Description = Description
};
string url = string.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl,
ResourceUriString);
RestRequestBuilder builder =
new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
protected override void ProcessRecord()
{
string uriString = Filename == null
? string.Format("adl://{0}.azuredatalakestore.net?domain={1}&appid={2}&folder={3}&clients={4}", Account,
Domain, AppId, Folder, NumClients <= 0? 1 : NumClients)
: string.Format("adl://{0}.azuredatalakestore.net?domain={1}&appid={2}&folder={3}&file={4}&clients={5}",
Account, Domain, AppId, Folder, Filename, NumClients <= 0 ? 1 : NumClients);
SubscriptionMetadata metadata = new SubscriptionMetadata
{
IsEphemeral = false,
NotifyAddress = uriString,
SymmetricKey = ClientSecret,
Description = Description
};
string url = string.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl,
ResourceUriString);
RestRequestBuilder builder =
new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
public async Task Should_create_a_subscription_based_on_event_type_full_name_for_an_event_name_reused_across_multiple_namespaces()
{
var namespaceManager = new NamespaceManagerAdapter(NamespaceManager.CreateFromConnectionString(AzureServiceBusConnectionString.Value));
await namespaceManager.CreateSubscription(new SubscriptionDescription(topicPath, typeof(Ns1.ReusedEvent).Name), new SqlSubscriptionFilter(typeof(Ns1.ReusedEvent)).Serialize());
var settings = new DefaultConfigurationValues().Apply(new SettingsHolder());
var creator = new AzureServiceBusSubscriptionCreatorV6(settings);
var metadata1 = new SubscriptionMetadata
{
SubscriptionNameBasedOnEventWithNamespace = typeof(Ns1.ReusedEvent).FullName,
Description = Guid.NewGuid().ToString()
};
var metadata2 = new SubscriptionMetadata
{
SubscriptionNameBasedOnEventWithNamespace = typeof(Ns2.ReusedEvent).FullName,
Description = Guid.NewGuid().ToString()
};
var shortedSubscriptionName = typeof(Ns2.ReusedEvent).FullName;
await creator.Create(topicPath, typeof(Ns1.ReusedEvent).Name, metadata1, new SqlSubscriptionFilter(typeof(Ns1.ReusedEvent)).Serialize(), namespaceManager);
await creator.Create(topicPath, typeof(Ns2.ReusedEvent).Name, metadata2, new SqlSubscriptionFilter(typeof(Ns2.ReusedEvent)).Serialize(), namespaceManager);
var subscriptionDescription = await namespaceManager.GetSubscription(topicPath, shortedSubscriptionName);
Assert.AreEqual(metadata2.Description, subscriptionDescription.UserMetadata);
Assert.AreEqual(metadata2.SubscriptionNameBasedOnEventWithNamespace, subscriptionDescription.Name);
}
protected override void ProcessRecord()
{
string uriString = string.Format("eh://{0}.servicebus.windows.net?hub={1}&keyname={2}&clients={3}", Account,
Hub, KeyName, NumClients <= 0 ? 1 : NumClients);
if (PartitionId != null)
{
uriString = string.Format("{0}&partitionid={1}", uriString, PartitionId);
}
SubscriptionMetadata metadata = new SubscriptionMetadata
{
IsEphemeral = false,
NotifyAddress = uriString,
SymmetricKey = Key,
Description = Description
};
string url = string.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl,
ResourceUriString);
RestRequestBuilder builder =
new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
protected override void ProcessRecord()
{
SubscriptionMetadata metadata = new SubscriptionMetadata
{
Identity = Identity,
Indexes = Indexes,
NotifyAddress = NotifyAddress,
TokenType = TokenType,
SymmetricKey = SymmetricKey,
Expires = Expires,
TTL = TTL,
SpoolRate = SpoolRate,
DurableMessaging = DurableMessaging
};
string url = string.Format("{0}/api/resource/subscribe?resourceuristring={1}", ServiceUrl,
ResourceUriString);
RestRequestBuilder builder =
new RestRequestBuilder("POST", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
string subscriptionUriString = request.Post <SubscriptionMetadata, string>(metadata);
WriteObject(subscriptionUriString);
}
public IoTHubSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
string keyName = nvc["keyname"];
deviceId = nvc["deviceid"];
methodName = nvc["method"];
propertyName = nvc["propname"];
propertyValue = nvc["propvalue"];
if (string.IsNullOrEmpty(methodName))
{
deviceClient = DeviceClient.CreateFromConnectionString(string.Format(
"HostName={0};DeviceId={1};SharedAccessKey={2}", uri.Authority, deviceId, metadata.SymmetricKey));
}
else
{
serviceClient = ServiceClient.CreateFromConnectionString(string.Format(
"HostName={0};SharedAccessKeyName={1};SharedAccessKey={2}", uri.Authority, keyName,
metadata.SymmetricKey));
}
}
public async Task <ActionResult <SubscriptionMetadata> > GetSubscriptionMetadata(string subscriptionUriString)
{
try
{
_ = subscriptionUriString ?? throw new ArgumentNullException(nameof(subscriptionUriString));
SubscriptionMetadata metadata = await graphManager.GetSubscriptionMetadataAsync(subscriptionUriString);
if (metadata == null)
{
logger?.LogWarning("Subscription metadata is null.");
}
else
{
logger?.LogInformation($"Subscription metadata '{metadata.SubscriptionUriString}' returned.");
}
return(StatusCode(200, metadata));
}
catch (Exception ex)
{
logger?.LogError(ex, "Error getting subscription metadata.");
return(StatusCode(500, ex.Message));
}
}
public async Task <CoapMessage> ObserveAsync(CoapMessage message)
{
if (!message.Observe.HasValue)
{
//RST because GET needs to be observe/unobserve
await logger?.LogWarningAsync($"CoAP observe received without Observe flag and will return RST for {session.Identity}");
await logger?.LogDebugAsync($"Returning RST because GET needs to be observe/unobserve for {session.Identity}");
return(new CoapResponse(message.MessageId, ResponseMessageType.Reset, ResponseCodeType.EmptyMessage));
}
CoapUri uri = new CoapUri(message.ResourceUri.ToString());
ResponseMessageType rmt = message.MessageType == CoapMessageType.Confirmable ? ResponseMessageType.Acknowledgement : ResponseMessageType.NonConfirmable;
ValidatorResult result = EventValidator.Validate(false, uri.Resource, channel, graphManager);
if (!result.Validated)
{
await logger?.LogErrorAsync($"{result.ErrorMessage} for {session.Identity}");
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Unauthorized, message.Token));
}
if (!message.Observe.Value)
{
//unsubscribe
await logger?.LogInformationAsync($"CoAP unobserve '{message.ResourceUri.ToString()}' for {session.Identity}.");
await adapter.UnsubscribeAsync(uri.Resource);
await logger?.LogDebugAsync($"CoAP unsubscribed '{message.ResourceUri.ToString()} for {session.Identity}'.");
coapObserved.Remove(uri.Resource);
}
else
{
//subscribe
SubscriptionMetadata metadata = new SubscriptionMetadata()
{
IsEphemeral = true,
Identity = session.Identity,
Indexes = session.Indexes
};
await logger?.LogInformationAsync($"CoAP subscribed '{message.ResourceUri.ToString()}' for {session.Identity}");
string subscriptionUriString = await adapter.SubscribeAsync(uri.Resource, metadata);
if (!coapObserved.ContainsKey(uri.Resource)) //add resource to observed list
{
coapObserved.Add(uri.Resource, message.Token);
await logger?.LogDebugAsync("Key added to observable resource.");
}
}
return(new CoapResponse(message.MessageId, rmt, ResponseCodeType.Valid, message.Token));
}
public WebHookSink(SubscriptionMetadata metadata, ILog logger)
: base(metadata, logger)
{
this.logger = logger;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
address = new Uri(metadata.NotifyAddress).ToString();
}
protected override void ProcessRecord()
{
string url = String.Format("{0}/api/Subscription/GetSubscriptionMetadata?subscriptionUriString={1}", ServiceUrl, SubscriptionUriString);
RestRequestBuilder builder = new RestRequestBuilder("GET", url, RestConstants.ContentType.Json, true, SecurityToken);
RestRequest request = new RestRequest(builder);
SubscriptionMetadata metadata = request.Get <SubscriptionMetadata>();
WriteObject(metadata);
}
public MachineLearningSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
this.logger = logger;
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
token = metadata.SymmetricKey;
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
outputPiSystem = nvc["r"];
}
public EventGridSink(SubscriptionMetadata metadata, ILog logger = null)
: base(metadata, logger)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
topicHostname = uri.Authority;
topicKey = metadata.SymmetricKey;
string uriString = new Uri(metadata.SubscriptionUriString).ToString();
resourceUriString = uriString.Replace("/" + uri.Segments[^ 1], "");
protected override void ProcessRecord()
{
List <KeyValuePair <string, string> > kvps = null;
if (!string.IsNullOrEmpty(IndexKeys) || string.IsNullOrEmpty(IndexValues) ||
string.IsNullOrEmpty(IndexKeys) || !string.IsNullOrEmpty(IndexValues))
{
throw new IndexOutOfRangeException("Index keys and values lengths do not match.");
}
if (!string.IsNullOrEmpty(IndexKeys) && !string.IsNullOrEmpty(IndexValues))
{
string[] keys = IndexKeys.Split(";", StringSplitOptions.RemoveEmptyEntries);
string[] values = IndexValues.Split(";", StringSplitOptions.RemoveEmptyEntries);
if (keys.Length != values.Length)
{
throw new IndexOutOfRangeException("Index keys and values lengths do not match.");
}
kvps = new List <KeyValuePair <string, string> >();
int index = 0;
while (index < keys.Length)
{
kvps.Add(new KeyValuePair <string, string>(keys[index], values[index]));
index++;
}
}
SubscriptionMetadata metadata = new SubscriptionMetadata
{
IsEphemeral = false,
SubscriptionUriString = SubscriptionUriString,
Description = Description,
Identity = Identity,
Indexes = kvps,
NotifyAddress = NotifyAddress,
Expires = Expires,
TokenType = TokenType,
TTL = TTL,
SymmetricKey = SymmetricKey,
SpoolRate = SpoolRate,
DurableMessaging = DurableMessaging,
ClaimKey = ClaimKey
};
string url = string.Format("{0}/api/subscription/upsertsubscriptionmetadata", ServiceUrl);
RestRequestBuilder builder =
new RestRequestBuilder("PUT", url, RestConstants.ContentType.Json, false, SecurityToken);
RestRequest request = new RestRequest(builder);
request.Put(metadata);
}
public async Task <SubscriptionMetadata> GetMetadataAsync()
{
SubscriptionMetadata metadata = null;
try
{
metadata = State.Metadata;
}
catch
{ }
return(await Task.FromResult <SubscriptionMetadata>(metadata));
}
public ServiceBusTopicSink(SubscriptionMetadata metadata)
: base(metadata)
{
auditor = AuditFactory.CreateSingleton().GetAuditor(AuditType.Message);
uri = new Uri(metadata.NotifyAddress);
NameValueCollection nvc = HttpUtility.ParseQueryString(uri.Query);
keyName = nvc["keyname"];
topic = nvc["topic"];
string symmetricKey = metadata.SymmetricKey;
connectionString = String.Format("Endpoint=sb://{0}/;SharedAccessKeyName={1};SharedAccessKey={2}", uri.Authority, keyName, symmetricKey);
}
public async Task <HttpResponseMessage> Subscribe(string resourceUriString, SubscriptionMetadata metadata)
{
try
{
string subscriptionUriString = await GraphManager.SubscribeAsync(resourceUriString, metadata);
return(Request.CreateResponse <string>(HttpStatusCode.OK, subscriptionUriString));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public async Task<ActionResult<string>> Subscribe(string resourceUriString, SubscriptionMetadata metadata)
{
try
{
string subscriptionUriString = await GraphManager.SubscribeAsync(resourceUriString, metadata);
return StatusCode(200, subscriptionUriString);
}
catch (Exception ex)
{
return StatusCode(500, ex.Message);
}
}
public async Task <ActionResult <SubscriptionMetadata> > GetSubscriptionMetadata(string subscriptionUriString)
{
try
{
SubscriptionMetadata metadata = await GraphManager.GetSubscriptionMetadataAsync(subscriptionUriString);
return(StatusCode(200, metadata));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public async Task <HttpResponseMessage> UpsertSubscriptionMetadata(SubscriptionMetadata metadata)
{
try
{
await GraphManager.UpsertSubscriptionMetadataAsync(metadata);
return(new HttpResponseMessage(HttpStatusCode.OK));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public async Task <HttpResponseMessage> GetSubscriptionMetadata(string subscriptionUriString)
{
try
{
SubscriptionMetadata metadata = await GraphManager.GetSubscriptionMetadataAsync(subscriptionUriString);
return(Request.CreateResponse <SubscriptionMetadata>(HttpStatusCode.OK, metadata));
}
catch (Exception ex)
{
return(Request.CreateErrorResponse(HttpStatusCode.InternalServerError, ex));
}
}
public async Task <IActionResult> UpsertSubscriptionMetadata(SubscriptionMetadata metadata)
{
try
{
await GraphManager.UpsertSubscriptionMetadataAsync(metadata);
return(StatusCode(200));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
